@azure/arm-iotfirmwaredefense 1.0.1-alpha.20250425.1 → 2.0.0-alpha.20250429.1

package/dist/commonjs/models/models.js

@@ -0,0 +1,954 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownVersions = exports.KnownSummaryType = exports.KnownCryptoKeyType = exports.KnownCertificateUsage = exports.KnownExecutableClass = exports.KnownCreatedByType = exports.KnownProvisioningState = exports.KnownStatus = exports.KnownActionType = exports.KnownOrigin = void 0;
+exports._operationListResultDeserializer = _operationListResultDeserializer;
+exports.operationArrayDeserializer = operationArrayDeserializer;
+exports.operationDeserializer = operationDeserializer;
+exports.operationDisplayDeserializer = operationDisplayDeserializer;
+exports.errorResponseDeserializer = errorResponseDeserializer;
+exports.errorDetailDeserializer = errorDetailDeserializer;
+exports.errorDetailArrayDeserializer = errorDetailArrayDeserializer;
+exports.errorAdditionalInfoArrayDeserializer = errorAdditionalInfoArrayDeserializer;
+exports.errorAdditionalInfoDeserializer = errorAdditionalInfoDeserializer;
+exports._errorAdditionalInfoInfoDeserializer = _errorAdditionalInfoInfoDeserializer;
+exports.firmwareSerializer = firmwareSerializer;
+exports.firmwareDeserializer = firmwareDeserializer;
+exports.firmwarePropertiesSerializer = firmwarePropertiesSerializer;
+exports.firmwarePropertiesDeserializer = firmwarePropertiesDeserializer;
+exports.statusMessageArraySerializer = statusMessageArraySerializer;
+exports.statusMessageArrayDeserializer = statusMessageArrayDeserializer;
+exports.statusMessageSerializer = statusMessageSerializer;
+exports.statusMessageDeserializer = statusMessageDeserializer;
+exports.proxyResourceSerializer = proxyResourceSerializer;
+exports.proxyResourceDeserializer = proxyResourceDeserializer;
+exports.resourceSerializer = resourceSerializer;
+exports.resourceDeserializer = resourceDeserializer;
+exports.systemDataDeserializer = systemDataDeserializer;
+exports.firmwareUpdateDefinitionSerializer = firmwareUpdateDefinitionSerializer;
+exports._firmwareListResultDeserializer = _firmwareListResultDeserializer;
+exports.firmwareArraySerializer = firmwareArraySerializer;
+exports.firmwareArrayDeserializer = firmwareArrayDeserializer;
+exports.workspaceSerializer = workspaceSerializer;
+exports.workspaceDeserializer = workspaceDeserializer;
+exports.workspacePropertiesSerializer = workspacePropertiesSerializer;
+exports.workspacePropertiesDeserializer = workspacePropertiesDeserializer;
+exports.skuSerializer = skuSerializer;
+exports.skuDeserializer = skuDeserializer;
+exports.trackedResourceSerializer = trackedResourceSerializer;
+exports.trackedResourceDeserializer = trackedResourceDeserializer;
+exports.workspaceUpdateSerializer = workspaceUpdateSerializer;
+exports._workspaceListResultDeserializer = _workspaceListResultDeserializer;
+exports.workspaceArraySerializer = workspaceArraySerializer;
+exports.workspaceArrayDeserializer = workspaceArrayDeserializer;
+exports.generateUploadUrlRequestSerializer = generateUploadUrlRequestSerializer;
+exports.urlTokenDeserializer = urlTokenDeserializer;
+exports._binaryHardeningResourceListResultDeserializer = _binaryHardeningResourceListResultDeserializer;
+exports.binaryHardeningResourceArrayDeserializer = binaryHardeningResourceArrayDeserializer;
+exports.binaryHardeningResourceDeserializer = binaryHardeningResourceDeserializer;
+exports.binaryHardeningResultDeserializer = binaryHardeningResultDeserializer;
+exports.binaryHardeningFeaturesDeserializer = binaryHardeningFeaturesDeserializer;
+exports._cryptoCertificateResourceListResultDeserializer = _cryptoCertificateResourceListResultDeserializer;
+exports.cryptoCertificateResourceArrayDeserializer = cryptoCertificateResourceArrayDeserializer;
+exports.cryptoCertificateResourceDeserializer = cryptoCertificateResourceDeserializer;
+exports.cryptoCertificateDeserializer = cryptoCertificateDeserializer;
+exports.cryptoCertificateEntityDeserializer = cryptoCertificateEntityDeserializer;
+exports.pairedKeyDeserializer = pairedKeyDeserializer;
+exports._cryptoKeyResourceListResultDeserializer = _cryptoKeyResourceListResultDeserializer;
+exports.cryptoKeyResourceArrayDeserializer = cryptoKeyResourceArrayDeserializer;
+exports.cryptoKeyResourceDeserializer = cryptoKeyResourceDeserializer;
+exports.cryptoKeyDeserializer = cryptoKeyDeserializer;
+exports._cveResourceListResultDeserializer = _cveResourceListResultDeserializer;
+exports.cveResourceArrayDeserializer = cveResourceArrayDeserializer;
+exports.cveResourceDeserializer = cveResourceDeserializer;
+exports.cveResultDeserializer = cveResultDeserializer;
+exports.cvssScoreArrayDeserializer = cvssScoreArrayDeserializer;
+exports.cvssScoreDeserializer = cvssScoreDeserializer;
+exports.cveLinkArrayDeserializer = cveLinkArrayDeserializer;
+exports.cveLinkDeserializer = cveLinkDeserializer;
+exports._passwordHashResourceListResultDeserializer = _passwordHashResourceListResultDeserializer;
+exports.passwordHashResourceArrayDeserializer = passwordHashResourceArrayDeserializer;
+exports.passwordHashResourceDeserializer = passwordHashResourceDeserializer;
+exports.passwordHashDeserializer = passwordHashDeserializer;
+exports._sbomComponentResourceListResultDeserializer = _sbomComponentResourceListResultDeserializer;
+exports.sbomComponentResourceArrayDeserializer = sbomComponentResourceArrayDeserializer;
+exports.sbomComponentResourceDeserializer = sbomComponentResourceDeserializer;
+exports.sbomComponentDeserializer = sbomComponentDeserializer;
+exports.summaryResourceDeserializer = summaryResourceDeserializer;
+exports.summaryResourcePropertiesDeserializer = summaryResourcePropertiesDeserializer;
+exports.summaryResourcePropertiesUnionDeserializer = summaryResourcePropertiesUnionDeserializer;
+exports.firmwareSummaryDeserializer = firmwareSummaryDeserializer;
+exports.cveSummaryDeserializer = cveSummaryDeserializer;
+exports.binaryHardeningSummaryResourceDeserializer = binaryHardeningSummaryResourceDeserializer;
+exports.cryptoCertificateSummaryResourceDeserializer = cryptoCertificateSummaryResourceDeserializer;
+exports.cryptoKeySummaryResourceDeserializer = cryptoKeySummaryResourceDeserializer;
+exports._summaryResourceListResultDeserializer = _summaryResourceListResultDeserializer;
+exports.summaryResourceArrayDeserializer = summaryResourceArrayDeserializer;
+exports.usageMetricDeserializer = usageMetricDeserializer;
+exports.usageMetricPropertiesDeserializer = usageMetricPropertiesDeserializer;
+exports._usageMetricListResultDeserializer = _usageMetricListResultDeserializer;
+exports.usageMetricArrayDeserializer = usageMetricArrayDeserializer;
+function _operationListResultDeserializer(item) {
+    return {
+        value: operationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function operationArrayDeserializer(result) {
+    return result.map((item) => {
+        return operationDeserializer(item);
+    });
+}
+function operationDeserializer(item) {
+    return {
+        name: item["name"],
+        isDataAction: item["isDataAction"],
+        display: !item["display"] ? item["display"] : operationDisplayDeserializer(item["display"]),
+        origin: item["origin"],
+        actionType: item["actionType"],
+    };
+}
+function operationDisplayDeserializer(item) {
+    return {
+        provider: item["provider"],
+        resource: item["resource"],
+        operation: item["operation"],
+        description: item["description"],
+    };
+}
+/** The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" */
+var KnownOrigin;
+(function (KnownOrigin) {
+    /** Indicates the operation is initiated by a user. */
+    KnownOrigin["User"] = "user";
+    /** Indicates the operation is initiated by a system. */
+    KnownOrigin["System"] = "system";
+    /** Indicates the operation is initiated by a user or system. */
+    KnownOrigin["UserSystem"] = "user,system";
+})(KnownOrigin || (exports.KnownOrigin = KnownOrigin = {}));
+/** Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. */
+var KnownActionType;
+(function (KnownActionType) {
+    /** Actions are for internal-only APIs. */
+    KnownActionType["Internal"] = "Internal";
+})(KnownActionType || (exports.KnownActionType = KnownActionType = {}));
+function errorResponseDeserializer(item) {
+    return {
+        error: !item["error"] ? item["error"] : errorDetailDeserializer(item["error"]),
+    };
+}
+function errorDetailDeserializer(item) {
+    return {
+        code: item["code"],
+        message: item["message"],
+        target: item["target"],
+        details: !item["details"] ? item["details"] : errorDetailArrayDeserializer(item["details"]),
+        additionalInfo: !item["additionalInfo"]
+            ? item["additionalInfo"]
+            : errorAdditionalInfoArrayDeserializer(item["additionalInfo"]),
+    };
+}
+function errorDetailArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorDetailDeserializer(item);
+    });
+}
+function errorAdditionalInfoArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorAdditionalInfoDeserializer(item);
+    });
+}
+function errorAdditionalInfoDeserializer(item) {
+    return {
+        type: item["type"],
+        info: !item["info"] ? item["info"] : _errorAdditionalInfoInfoDeserializer(item["info"]),
+    };
+}
+function _errorAdditionalInfoInfoDeserializer(item) {
+    return item;
+}
+function firmwareSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : firmwarePropertiesSerializer(item["properties"]),
+    };
+}
+function firmwareDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : firmwarePropertiesDeserializer(item["properties"]),
+    };
+}
+function firmwarePropertiesSerializer(item) {
+    return {
+        fileName: item["fileName"],
+        vendor: item["vendor"],
+        model: item["model"],
+        version: item["version"],
+        description: item["description"],
+        fileSize: item["fileSize"],
+        status: item["status"],
+        statusMessages: !item["statusMessages"]
+            ? item["statusMessages"]
+            : statusMessageArraySerializer(item["statusMessages"]),
+    };
+}
+function firmwarePropertiesDeserializer(item) {
+    return {
+        fileName: item["fileName"],
+        vendor: item["vendor"],
+        model: item["model"],
+        version: item["version"],
+        description: item["description"],
+        fileSize: item["fileSize"],
+        status: item["status"],
+        statusMessages: !item["statusMessages"]
+            ? item["statusMessages"]
+            : statusMessageArrayDeserializer(item["statusMessages"]),
+        provisioningState: item["provisioningState"],
+    };
+}
+/** The status of a firmware analysis job. */
+var KnownStatus;
+(function (KnownStatus) {
+    /** The analysis job is queued */
+    KnownStatus["Pending"] = "Pending";
+    /** The firmware is currently being extracted */
+    KnownStatus["Extracting"] = "Extracting";
+    /** Analysis is being run on the firmware */
+    KnownStatus["Analyzing"] = "Analyzing";
+    /** Analysis job results are ready */
+    KnownStatus["Ready"] = "Ready";
+    /** An error occurred while running firmware analysis */
+    KnownStatus["Error"] = "Error";
+})(KnownStatus || (exports.KnownStatus = KnownStatus = {}));
+function statusMessageArraySerializer(result) {
+    return result.map((item) => {
+        return statusMessageSerializer(item);
+    });
+}
+function statusMessageArrayDeserializer(result) {
+    return result.map((item) => {
+        return statusMessageDeserializer(item);
+    });
+}
+function statusMessageSerializer(item) {
+    return { errorCode: item["errorCode"], message: item["message"] };
+}
+function statusMessageDeserializer(item) {
+    return {
+        errorCode: item["errorCode"],
+        message: item["message"],
+    };
+}
+/** The status of a firmware analysis job. */
+var KnownProvisioningState;
+(function (KnownProvisioningState) {
+    /** The request has successfully completed. */
+    KnownProvisioningState["Succeeded"] = "Succeeded";
+    /** There was an error during the request. */
+    KnownProvisioningState["Failed"] = "Failed";
+    /** The request was canceled. */
+    KnownProvisioningState["Canceled"] = "Canceled";
+    /** The request is queued and awaiting execution */
+    KnownProvisioningState["Pending"] = "Pending";
+    /** The Firmware is currently being extracted. */
+    KnownProvisioningState["Extracting"] = "Extracting";
+    /** Analysis is being run on the firmware */
+    KnownProvisioningState["Analyzing"] = "Analyzing";
+})(KnownProvisioningState || (exports.KnownProvisioningState = KnownProvisioningState = {}));
+function proxyResourceSerializer(item) {
+    return item;
+}
+function proxyResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+function resourceSerializer(item) {
+    return item;
+}
+function resourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+function systemDataDeserializer(item) {
+    return {
+        createdBy: item["createdBy"],
+        createdByType: item["createdByType"],
+        createdAt: !item["createdAt"] ? item["createdAt"] : new Date(item["createdAt"]),
+        lastModifiedBy: item["lastModifiedBy"],
+        lastModifiedByType: item["lastModifiedByType"],
+        lastModifiedAt: !item["lastModifiedAt"]
+            ? item["lastModifiedAt"]
+            : new Date(item["lastModifiedAt"]),
+    };
+}
+/** The kind of entity that created the resource. */
+var KnownCreatedByType;
+(function (KnownCreatedByType) {
+    /** The entity was created by a user. */
+    KnownCreatedByType["User"] = "User";
+    /** The entity was created by an application. */
+    KnownCreatedByType["Application"] = "Application";
+    /** The entity was created by a managed identity. */
+    KnownCreatedByType["ManagedIdentity"] = "ManagedIdentity";
+    /** The entity was created by a key. */
+    KnownCreatedByType["Key"] = "Key";
+})(KnownCreatedByType || (exports.KnownCreatedByType = KnownCreatedByType = {}));
+function firmwareUpdateDefinitionSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : firmwarePropertiesSerializer(item["properties"]),
+    };
+}
+function _firmwareListResultDeserializer(item) {
+    return {
+        value: firmwareArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function firmwareArraySerializer(result) {
+    return result.map((item) => {
+        return firmwareSerializer(item);
+    });
+}
+function firmwareArrayDeserializer(result) {
+    return result.map((item) => {
+        return firmwareDeserializer(item);
+    });
+}
+function workspaceSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : workspacePropertiesSerializer(item["properties"]),
+        sku: !item["sku"] ? item["sku"] : skuSerializer(item["sku"]),
+    };
+}
+function workspaceDeserializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : workspacePropertiesDeserializer(item["properties"]),
+        sku: !item["sku"] ? item["sku"] : skuDeserializer(item["sku"]),
+    };
+}
+function workspacePropertiesSerializer(item) {
+    return item;
+}
+function workspacePropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+    };
+}
+function skuSerializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+        size: item["size"],
+        family: item["family"],
+        capacity: item["capacity"],
+    };
+}
+function skuDeserializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+        size: item["size"],
+        family: item["family"],
+        capacity: item["capacity"],
+    };
+}
+function trackedResourceSerializer(item) {
+    return { tags: item["tags"], location: item["location"] };
+}
+function trackedResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        tags: item["tags"],
+        location: item["location"],
+    };
+}
+function workspaceUpdateSerializer(item) {
+    return {
+        sku: !item["sku"] ? item["sku"] : skuSerializer(item["sku"]),
+        tags: item["tags"],
+    };
+}
+function _workspaceListResultDeserializer(item) {
+    return {
+        value: workspaceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function workspaceArraySerializer(result) {
+    return result.map((item) => {
+        return workspaceSerializer(item);
+    });
+}
+function workspaceArrayDeserializer(result) {
+    return result.map((item) => {
+        return workspaceDeserializer(item);
+    });
+}
+function generateUploadUrlRequestSerializer(item) {
+    return { firmwareId: item["firmwareId"] };
+}
+function urlTokenDeserializer(item) {
+    return {
+        url: item["url"],
+    };
+}
+function _binaryHardeningResourceListResultDeserializer(item) {
+    return {
+        value: binaryHardeningResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function binaryHardeningResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return binaryHardeningResourceDeserializer(item);
+    });
+}
+function binaryHardeningResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : binaryHardeningResultDeserializer(item["properties"]),
+    };
+}
+function binaryHardeningResultDeserializer(item) {
+    return {
+        binaryHardeningId: item["binaryHardeningId"],
+        securityHardeningFeatures: !item["securityHardeningFeatures"]
+            ? item["securityHardeningFeatures"]
+            : binaryHardeningFeaturesDeserializer(item["securityHardeningFeatures"]),
+        executableArchitecture: item["executableArchitecture"],
+        filePath: item["filePath"],
+        executableClass: item["executableClass"],
+        runpath: item["runpath"],
+        rpath: item["rpath"],
+        provisioningState: item["provisioningState"],
+    };
+}
+function binaryHardeningFeaturesDeserializer(item) {
+    return {
+        noExecute: item["noExecute"],
+        positionIndependentExecutable: item["positionIndependentExecutable"],
+        relocationReadOnly: item["relocationReadOnly"],
+        canary: item["canary"],
+        stripped: item["stripped"],
+    };
+}
+/** String to indicate if the executable is 32 or 64 bit. */
+var KnownExecutableClass;
+(function (KnownExecutableClass) {
+    /** The binary is 32-bit. */
+    KnownExecutableClass["X86"] = "x86";
+    /** The binary is 64-bit. */
+    KnownExecutableClass["X64"] = "x64";
+})(KnownExecutableClass || (exports.KnownExecutableClass = KnownExecutableClass = {}));
+function _cryptoCertificateResourceListResultDeserializer(item) {
+    return {
+        value: cryptoCertificateResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function cryptoCertificateResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return cryptoCertificateResourceDeserializer(item);
+    });
+}
+function cryptoCertificateResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : cryptoCertificateDeserializer(item["properties"]),
+    };
+}
+function cryptoCertificateDeserializer(item) {
+    return {
+        cryptoCertId: item["cryptoCertId"],
+        certificateName: item["certificateName"],
+        subject: !item["subject"]
+            ? item["subject"]
+            : cryptoCertificateEntityDeserializer(item["subject"]),
+        issuer: !item["issuer"] ? item["issuer"] : cryptoCertificateEntityDeserializer(item["issuer"]),
+        issuedDate: !item["issuedDate"] ? item["issuedDate"] : new Date(item["issuedDate"]),
+        expirationDate: !item["expirationDate"]
+            ? item["expirationDate"]
+            : new Date(item["expirationDate"]),
+        certificateRole: item["certificateRole"],
+        signatureAlgorithm: item["signatureAlgorithm"],
+        certificateKeySize: item["certificateKeySize"],
+        certificateKeyAlgorithm: item["certificateKeyAlgorithm"],
+        encoding: item["encoding"],
+        serialNumber: item["serialNumber"],
+        fingerprint: item["fingerprint"],
+        certificateUsage: !item["certificateUsage"]
+            ? item["certificateUsage"]
+            : item["certificateUsage"].map((p) => {
+                return p;
+            }),
+        filePaths: !item["filePaths"]
+            ? item["filePaths"]
+            : item["filePaths"].map((p) => {
+                return p;
+            }),
+        pairedKey: !item["pairedKey"] ? item["pairedKey"] : pairedKeyDeserializer(item["pairedKey"]),
+        isExpired: item["isExpired"],
+        isSelfSigned: item["isSelfSigned"],
+        isWeakSignature: item["isWeakSignature"],
+        isShortKeySize: item["isShortKeySize"],
+        provisioningState: item["provisioningState"],
+    };
+}
+function cryptoCertificateEntityDeserializer(item) {
+    return {
+        commonName: item["commonName"],
+        organization: item["organization"],
+        organizationalUnit: item["organizationalUnit"],
+        state: item["state"],
+        country: item["country"],
+    };
+}
+/** Activities for which the cryptographic certificate can be used. */
+var KnownCertificateUsage;
+(function (KnownCertificateUsage) {
+    /** This certificate can be used to add a signature to a message */
+    KnownCertificateUsage["DigitalSignature"] = "digitalSignature";
+    /** This certificates provides a non-repudiation service that protects against false denial of a message */
+    KnownCertificateUsage["NonRepudiation"] = "nonRepudiation";
+    /** A synonym for NonRepudiation used in newer x509 certificates */
+    KnownCertificateUsage["ContentCommitment"] = "contentCommitment";
+    /** This certificate can be used to encrypt a private or secret key */
+    KnownCertificateUsage["KeyEncipherment"] = "keyEncipherment";
+    /** This certificate can be used to decrypt a private or secret key */
+    KnownCertificateUsage["DataEncipherment"] = "dataEncipherment";
+    /** This certificate can be used to perform a key agreement, such as with a Diffie-Hellman key exchange */
+    KnownCertificateUsage["KeyAgreement"] = "keyAgreement";
+    /** This certificate can be used to verify a other public keys */
+    KnownCertificateUsage["KeyCertSign"] = "keyCertSign";
+    /** This certificate can be used to verify a certificate revocation list */
+    KnownCertificateUsage["CRLSign"] = "crlSign";
+    /** This certificate can be only be used to encrypt data */
+    KnownCertificateUsage["EncipherOnly"] = "encipherOnly";
+    /** This certificate can only be used to decrypt data */
+    KnownCertificateUsage["DecipherOnly"] = "decipherOnly";
+    /** This certificate can be used to authenticate a server in a TLS/SSL connection */
+    KnownCertificateUsage["ServerAuthentication"] = "serverAuth";
+    /** This certificate can be used to authenticate a client in a TLS/SSL connection */
+    KnownCertificateUsage["ClientAuthentication"] = "clientAuth";
+    /** This certificate can be used to authenticate a code object */
+    KnownCertificateUsage["CodeSigning"] = "codeSigning";
+    /** This certificate can be used to authenticate an email address */
+    KnownCertificateUsage["EmailProtection"] = "emailProtection";
+    /** This certificate binds the hash of an object to a time */
+    KnownCertificateUsage["TimeStamping"] = "timeStamping";
+    /** This certificate can be used to sign OCSP responses */
+    KnownCertificateUsage["OcspSigning"] = "ocspSigning";
+})(KnownCertificateUsage || (exports.KnownCertificateUsage = KnownCertificateUsage = {}));
+function pairedKeyDeserializer(item) {
+    return {
+        pairedKeyId: item["pairedKeyId"],
+        type: item["type"],
+    };
+}
+function _cryptoKeyResourceListResultDeserializer(item) {
+    return {
+        value: cryptoKeyResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function cryptoKeyResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return cryptoKeyResourceDeserializer(item);
+    });
+}
+function cryptoKeyResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : cryptoKeyDeserializer(item["properties"]),
+    };
+}
+function cryptoKeyDeserializer(item) {
+    return {
+        cryptoKeyId: item["cryptoKeyId"],
+        keyType: item["keyType"],
+        cryptoKeySize: item["cryptoKeySize"],
+        keyAlgorithm: item["keyAlgorithm"],
+        usage: !item["usage"]
+            ? item["usage"]
+            : item["usage"].map((p) => {
+                return p;
+            }),
+        filePaths: !item["filePaths"]
+            ? item["filePaths"]
+            : item["filePaths"].map((p) => {
+                return p;
+            }),
+        pairedKey: !item["pairedKey"] ? item["pairedKey"] : pairedKeyDeserializer(item["pairedKey"]),
+        isShortKeySize: item["isShortKeySize"],
+        provisioningState: item["provisioningState"],
+    };
+}
+/** Different types of cryptographic keys. */
+var KnownCryptoKeyType;
+(function (KnownCryptoKeyType) {
+    /** The key is an asymmetric public key. */
+    KnownCryptoKeyType["Public"] = "Public";
+    /** The key is an asymmetric private key. */
+    KnownCryptoKeyType["Private"] = "Private";
+})(KnownCryptoKeyType || (exports.KnownCryptoKeyType = KnownCryptoKeyType = {}));
+function _cveResourceListResultDeserializer(item) {
+    return {
+        value: cveResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function cveResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return cveResourceDeserializer(item);
+    });
+}
+function cveResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : cveResultDeserializer(item["properties"]),
+    };
+}
+function cveResultDeserializer(item) {
+    return {
+        cveId: item["cveId"],
+        componentId: item["componentId"],
+        componentName: item["componentName"],
+        componentVersion: item["componentVersion"],
+        severity: item["severity"],
+        cveName: item["cveName"],
+        effectiveCvssScore: item["effectiveCvssScore"],
+        effectiveCvssVersion: item["effectiveCvssVersion"],
+        cvssScores: !item["cvssScores"]
+            ? item["cvssScores"]
+            : cvssScoreArrayDeserializer(item["cvssScores"]),
+        links: !item["links"] ? item["links"] : cveLinkArrayDeserializer(item["links"]),
+        description: item["description"],
+        provisioningState: item["provisioningState"],
+    };
+}
+function cvssScoreArrayDeserializer(result) {
+    return result.map((item) => {
+        return cvssScoreDeserializer(item);
+    });
+}
+function cvssScoreDeserializer(item) {
+    return {
+        version: item["version"],
+        score: item["score"],
+    };
+}
+function cveLinkArrayDeserializer(result) {
+    return result.map((item) => {
+        return cveLinkDeserializer(item);
+    });
+}
+function cveLinkDeserializer(item) {
+    return {
+        href: item["href"],
+        label: item["label"],
+    };
+}
+function _passwordHashResourceListResultDeserializer(item) {
+    return {
+        value: passwordHashResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function passwordHashResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return passwordHashResourceDeserializer(item);
+    });
+}
+function passwordHashResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : passwordHashDeserializer(item["properties"]),
+    };
+}
+function passwordHashDeserializer(item) {
+    return {
+        passwordHashId: item["passwordHashId"],
+        filePath: item["filePath"],
+        salt: item["salt"],
+        hash: item["hash"],
+        context: item["context"],
+        username: item["username"],
+        algorithm: item["algorithm"],
+        provisioningState: item["provisioningState"],
+    };
+}
+function _sbomComponentResourceListResultDeserializer(item) {
+    return {
+        value: sbomComponentResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function sbomComponentResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return sbomComponentResourceDeserializer(item);
+    });
+}
+function sbomComponentResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : sbomComponentDeserializer(item["properties"]),
+    };
+}
+function sbomComponentDeserializer(item) {
+    return {
+        componentId: item["componentId"],
+        componentName: item["componentName"],
+        version: item["version"],
+        license: item["license"],
+        filePaths: !item["filePaths"]
+            ? item["filePaths"]
+            : item["filePaths"].map((p) => {
+                return p;
+            }),
+        provisioningState: item["provisioningState"],
+    };
+}
+function summaryResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : summaryResourcePropertiesUnionDeserializer(item["properties"]),
+    };
+}
+function summaryResourcePropertiesDeserializer(item) {
+    return {
+        summaryType: item["summaryType"],
+        provisioningState: item["provisioningState"],
+    };
+}
+function summaryResourcePropertiesUnionDeserializer(item) {
+    switch (item.summaryType) {
+        case "Firmware":
+            return firmwareSummaryDeserializer(item);
+        case "CommonVulnerabilitiesAndExposures":
+            return cveSummaryDeserializer(item);
+        case "BinaryHardening":
+            return binaryHardeningSummaryResourceDeserializer(item);
+        case "CryptoCertificate":
+            return cryptoCertificateSummaryResourceDeserializer(item);
+        case "CryptoKey":
+            return cryptoKeySummaryResourceDeserializer(item);
+        default:
+            return summaryResourcePropertiesDeserializer(item);
+    }
+}
+/** Describes the type of summary. */
+var KnownSummaryType;
+(function (KnownSummaryType) {
+    /** The summary contains information about the submitted firmware */
+    KnownSummaryType["Firmware"] = "Firmware";
+    /** The summary contains information about the Common Vulnerabilities and Exposures analysis results */
+    KnownSummaryType["CommonVulnerabilitiesAndExposures"] = "CommonVulnerabilitiesAndExposures";
+    /** The summary contains information about the binary hardening analysis results */
+    KnownSummaryType["BinaryHardening"] = "BinaryHardening";
+    /** The summary contains information about the cryptographic certificate analysis results */
+    KnownSummaryType["CryptoCertificate"] = "CryptoCertificate";
+    /** The summary contains information about the cryptographic key analysis results */
+    KnownSummaryType["CryptoKey"] = "CryptoKey";
+})(KnownSummaryType || (exports.KnownSummaryType = KnownSummaryType = {}));
+function firmwareSummaryDeserializer(item) {
+    return {
+        summaryType: item["summaryType"],
+        provisioningState: item["provisioningState"],
+        extractedSize: item["extractedSize"],
+        fileSize: item["fileSize"],
+        extractedFileCount: item["extractedFileCount"],
+        componentCount: item["componentCount"],
+        binaryCount: item["binaryCount"],
+        analysisTimeSeconds: item["analysisTimeSeconds"],
+        rootFileSystems: item["rootFileSystems"],
+    };
+}
+function cveSummaryDeserializer(item) {
+    return {
+        summaryType: item["summaryType"],
+        provisioningState: item["provisioningState"],
+        criticalCveCount: item["criticalCveCount"],
+        highCveCount: item["highCveCount"],
+        mediumCveCount: item["mediumCveCount"],
+        lowCveCount: item["lowCveCount"],
+        unknownCveCount: item["unknownCveCount"],
+    };
+}
+function binaryHardeningSummaryResourceDeserializer(item) {
+    return {
+        summaryType: item["summaryType"],
+        provisioningState: item["provisioningState"],
+        totalFiles: item["totalFiles"],
+        notExecutableStackCount: item["notExecutableStackCount"],
+        positionIndependentExecutableCount: item["positionIndependentExecutableCount"],
+        relocationReadOnlyCount: item["relocationReadOnlyCount"],
+        stackCanaryCount: item["stackCanaryCount"],
+        strippedBinaryCount: item["strippedBinaryCount"],
+    };
+}
+function cryptoCertificateSummaryResourceDeserializer(item) {
+    return {
+        summaryType: item["summaryType"],
+        provisioningState: item["provisioningState"],
+        totalCertificateCount: item["totalCertificateCount"],
+        pairedKeyCount: item["pairedKeyCount"],
+        expiredCertificateCount: item["expiredCertificateCount"],
+        expiringSoonCertificateCount: item["expiringSoonCertificateCount"],
+        weakSignatureCount: item["weakSignatureCount"],
+        selfSignedCertificateCount: item["selfSignedCertificateCount"],
+        shortKeySizeCount: item["shortKeySizeCount"],
+    };
+}
+function cryptoKeySummaryResourceDeserializer(item) {
+    return {
+        summaryType: item["summaryType"],
+        provisioningState: item["provisioningState"],
+        totalKeyCount: item["totalKeyCount"],
+        publicKeyCount: item["publicKeyCount"],
+        privateKeyCount: item["privateKeyCount"],
+        pairedKeyCount: item["pairedKeyCount"],
+        shortKeySizeCount: item["shortKeySizeCount"],
+    };
+}
+function _summaryResourceListResultDeserializer(item) {
+    return {
+        value: summaryResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function summaryResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return summaryResourceDeserializer(item);
+    });
+}
+function usageMetricDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : usageMetricPropertiesDeserializer(item["properties"]),
+    };
+}
+function usageMetricPropertiesDeserializer(item) {
+    return {
+        monthlyFirmwareUploadCount: item["monthlyFirmwareUploadCount"],
+        totalFirmwareCount: item["totalFirmwareCount"],
+        provisioningState: item["provisioningState"],
+    };
+}
+function _usageMetricListResultDeserializer(item) {
+    return {
+        value: usageMetricArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function usageMetricArrayDeserializer(result) {
+    return result.map((item) => {
+        return usageMetricDeserializer(item);
+    });
+}
+/** The available API versions. */
+var KnownVersions;
+(function (KnownVersions) {
+    /** The 2025-04-01 API version. */
+    KnownVersions["V20250401Preview"] = "2025-04-01-preview";
+})(KnownVersions || (exports.KnownVersions = KnownVersions = {}));
+//# sourceMappingURL=models.js.map