@azure/arm-iotfirmwaredefense 1.0.1-alpha.20250424.1 → 2.0.0-alpha.20250428.3

package/dist/browser/models/models.js

@@ -0,0 +1,865 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export function _operationListResultDeserializer(item) {
+    return {
+        value: operationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function operationArrayDeserializer(result) {
+    return result.map((item) => {
+        return operationDeserializer(item);
+    });
+}
+export function operationDeserializer(item) {
+    return {
+        name: item["name"],
+        isDataAction: item["isDataAction"],
+        display: !item["display"] ? item["display"] : operationDisplayDeserializer(item["display"]),
+        origin: item["origin"],
+        actionType: item["actionType"],
+    };
+}
+export 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" */
+export 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 || (KnownOrigin = {}));
+/** Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. */
+export var KnownActionType;
+(function (KnownActionType) {
+    /** Actions are for internal-only APIs. */
+    KnownActionType["Internal"] = "Internal";
+})(KnownActionType || (KnownActionType = {}));
+export function errorResponseDeserializer(item) {
+    return {
+        error: !item["error"] ? item["error"] : errorDetailDeserializer(item["error"]),
+    };
+}
+export 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"]),
+    };
+}
+export function errorDetailArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorDetailDeserializer(item);
+    });
+}
+export function errorAdditionalInfoArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorAdditionalInfoDeserializer(item);
+    });
+}
+export function errorAdditionalInfoDeserializer(item) {
+    return {
+        type: item["type"],
+        info: !item["info"] ? item["info"] : _errorAdditionalInfoInfoDeserializer(item["info"]),
+    };
+}
+export function _errorAdditionalInfoInfoDeserializer(item) {
+    return item;
+}
+export function firmwareSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : firmwarePropertiesSerializer(item["properties"]),
+    };
+}
+export 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"]),
+    };
+}
+export 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"]),
+    };
+}
+export 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. */
+export 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 || (KnownStatus = {}));
+export function statusMessageArraySerializer(result) {
+    return result.map((item) => {
+        return statusMessageSerializer(item);
+    });
+}
+export function statusMessageArrayDeserializer(result) {
+    return result.map((item) => {
+        return statusMessageDeserializer(item);
+    });
+}
+export function statusMessageSerializer(item) {
+    return { errorCode: item["errorCode"], message: item["message"] };
+}
+export function statusMessageDeserializer(item) {
+    return {
+        errorCode: item["errorCode"],
+        message: item["message"],
+    };
+}
+/** The status of a firmware analysis job. */
+export 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 || (KnownProvisioningState = {}));
+export function proxyResourceSerializer(item) {
+    return item;
+}
+export function proxyResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+export function resourceSerializer(item) {
+    return item;
+}
+export function resourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+export 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. */
+export 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 || (KnownCreatedByType = {}));
+export function firmwareUpdateDefinitionSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : firmwarePropertiesSerializer(item["properties"]),
+    };
+}
+export function _firmwareListResultDeserializer(item) {
+    return {
+        value: firmwareArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function firmwareArraySerializer(result) {
+    return result.map((item) => {
+        return firmwareSerializer(item);
+    });
+}
+export function firmwareArrayDeserializer(result) {
+    return result.map((item) => {
+        return firmwareDeserializer(item);
+    });
+}
+export 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"]),
+    };
+}
+export 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"]),
+    };
+}
+export function workspacePropertiesSerializer(item) {
+    return item;
+}
+export function workspacePropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+    };
+}
+export function skuSerializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+        size: item["size"],
+        family: item["family"],
+        capacity: item["capacity"],
+    };
+}
+export function skuDeserializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+        size: item["size"],
+        family: item["family"],
+        capacity: item["capacity"],
+    };
+}
+export function trackedResourceSerializer(item) {
+    return { tags: item["tags"], location: item["location"] };
+}
+export 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"],
+    };
+}
+export function workspaceUpdateSerializer(item) {
+    return {
+        sku: !item["sku"] ? item["sku"] : skuSerializer(item["sku"]),
+        tags: item["tags"],
+    };
+}
+export function _workspaceListResultDeserializer(item) {
+    return {
+        value: workspaceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function workspaceArraySerializer(result) {
+    return result.map((item) => {
+        return workspaceSerializer(item);
+    });
+}
+export function workspaceArrayDeserializer(result) {
+    return result.map((item) => {
+        return workspaceDeserializer(item);
+    });
+}
+export function generateUploadUrlRequestSerializer(item) {
+    return { firmwareId: item["firmwareId"] };
+}
+export function urlTokenDeserializer(item) {
+    return {
+        url: item["url"],
+    };
+}
+export function _binaryHardeningResourceListResultDeserializer(item) {
+    return {
+        value: binaryHardeningResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function binaryHardeningResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return binaryHardeningResourceDeserializer(item);
+    });
+}
+export 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"]),
+    };
+}
+export 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"],
+    };
+}
+export 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. */
+export var KnownExecutableClass;
+(function (KnownExecutableClass) {
+    /** The binary is 32-bit. */
+    KnownExecutableClass["X86"] = "x86";
+    /** The binary is 64-bit. */
+    KnownExecutableClass["X64"] = "x64";
+})(KnownExecutableClass || (KnownExecutableClass = {}));
+export function _cryptoCertificateResourceListResultDeserializer(item) {
+    return {
+        value: cryptoCertificateResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function cryptoCertificateResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return cryptoCertificateResourceDeserializer(item);
+    });
+}
+export 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"]),
+    };
+}
+export 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"],
+    };
+}
+export 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. */
+export 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 || (KnownCertificateUsage = {}));
+export function pairedKeyDeserializer(item) {
+    return {
+        pairedKeyId: item["pairedKeyId"],
+        type: item["type"],
+    };
+}
+export function _cryptoKeyResourceListResultDeserializer(item) {
+    return {
+        value: cryptoKeyResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function cryptoKeyResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return cryptoKeyResourceDeserializer(item);
+    });
+}
+export 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"]),
+    };
+}
+export 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. */
+export 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 || (KnownCryptoKeyType = {}));
+export function _cveResourceListResultDeserializer(item) {
+    return {
+        value: cveResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function cveResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return cveResourceDeserializer(item);
+    });
+}
+export 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"]),
+    };
+}
+export 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"],
+    };
+}
+export function cvssScoreArrayDeserializer(result) {
+    return result.map((item) => {
+        return cvssScoreDeserializer(item);
+    });
+}
+export function cvssScoreDeserializer(item) {
+    return {
+        version: item["version"],
+        score: item["score"],
+    };
+}
+export function cveLinkArrayDeserializer(result) {
+    return result.map((item) => {
+        return cveLinkDeserializer(item);
+    });
+}
+export function cveLinkDeserializer(item) {
+    return {
+        href: item["href"],
+        label: item["label"],
+    };
+}
+export function _passwordHashResourceListResultDeserializer(item) {
+    return {
+        value: passwordHashResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function passwordHashResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return passwordHashResourceDeserializer(item);
+    });
+}
+export 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"]),
+    };
+}
+export 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"],
+    };
+}
+export function _sbomComponentResourceListResultDeserializer(item) {
+    return {
+        value: sbomComponentResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function sbomComponentResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return sbomComponentResourceDeserializer(item);
+    });
+}
+export 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"]),
+    };
+}
+export 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"],
+    };
+}
+export 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"]),
+    };
+}
+export function summaryResourcePropertiesDeserializer(item) {
+    return {
+        summaryType: item["summaryType"],
+        provisioningState: item["provisioningState"],
+    };
+}
+export 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. */
+export 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 || (KnownSummaryType = {}));
+export 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"],
+    };
+}
+export 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"],
+    };
+}
+export 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"],
+    };
+}
+export 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"],
+    };
+}
+export 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"],
+    };
+}
+export function _summaryResourceListResultDeserializer(item) {
+    return {
+        value: summaryResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function summaryResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return summaryResourceDeserializer(item);
+    });
+}
+export 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"]),
+    };
+}
+export function usageMetricPropertiesDeserializer(item) {
+    return {
+        monthlyFirmwareUploadCount: item["monthlyFirmwareUploadCount"],
+        totalFirmwareCount: item["totalFirmwareCount"],
+        provisioningState: item["provisioningState"],
+    };
+}
+export function _usageMetricListResultDeserializer(item) {
+    return {
+        value: usageMetricArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function usageMetricArrayDeserializer(result) {
+    return result.map((item) => {
+        return usageMetricDeserializer(item);
+    });
+}
+/** The available API versions. */
+export var KnownVersions;
+(function (KnownVersions) {
+    /** The 2025-04-01 API version. */
+    KnownVersions["V20250401Preview"] = "2025-04-01-preview";
+})(KnownVersions || (KnownVersions = {}));
+//# sourceMappingURL=models.js.map