@azure/arm-storageactions 1.0.0-beta.1 → 1.0.0

package/dist/commonjs/models/models.js

@@ -0,0 +1,611 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownVersions = exports.KnownRunResult = exports.KnownRunStatusEnum = exports.KnownMatchedBlockName = exports.KnownCreatedByType = exports.KnownProvisioningState = exports.KnownOnFailure = exports.KnownOnSuccess = exports.KnownStorageTaskOperationName = exports.KnownManagedServiceIdentityType = 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.storageTaskSerializer = storageTaskSerializer;
+exports.storageTaskDeserializer = storageTaskDeserializer;
+exports.managedServiceIdentitySerializer = managedServiceIdentitySerializer;
+exports.managedServiceIdentityDeserializer = managedServiceIdentityDeserializer;
+exports.userAssignedIdentitySerializer = userAssignedIdentitySerializer;
+exports.userAssignedIdentityDeserializer = userAssignedIdentityDeserializer;
+exports.storageTaskPropertiesSerializer = storageTaskPropertiesSerializer;
+exports.storageTaskPropertiesDeserializer = storageTaskPropertiesDeserializer;
+exports.storageTaskActionSerializer = storageTaskActionSerializer;
+exports.storageTaskActionDeserializer = storageTaskActionDeserializer;
+exports.ifConditionSerializer = ifConditionSerializer;
+exports.ifConditionDeserializer = ifConditionDeserializer;
+exports.storageTaskOperationArraySerializer = storageTaskOperationArraySerializer;
+exports.storageTaskOperationArrayDeserializer = storageTaskOperationArrayDeserializer;
+exports.storageTaskOperationSerializer = storageTaskOperationSerializer;
+exports.storageTaskOperationDeserializer = storageTaskOperationDeserializer;
+exports.elseConditionSerializer = elseConditionSerializer;
+exports.elseConditionDeserializer = elseConditionDeserializer;
+exports.trackedResourceSerializer = trackedResourceSerializer;
+exports.trackedResourceDeserializer = trackedResourceDeserializer;
+exports.resourceSerializer = resourceSerializer;
+exports.resourceDeserializer = resourceDeserializer;
+exports.systemDataDeserializer = systemDataDeserializer;
+exports.storageTaskUpdateParametersSerializer = storageTaskUpdateParametersSerializer;
+exports.storageTaskUpdatePropertiesSerializer = storageTaskUpdatePropertiesSerializer;
+exports._storageTasksListResultDeserializer = _storageTasksListResultDeserializer;
+exports.storageTaskArraySerializer = storageTaskArraySerializer;
+exports.storageTaskArrayDeserializer = storageTaskArrayDeserializer;
+exports.storageTaskPreviewActionSerializer = storageTaskPreviewActionSerializer;
+exports.storageTaskPreviewActionDeserializer = storageTaskPreviewActionDeserializer;
+exports.storageTaskPreviewActionPropertiesSerializer = storageTaskPreviewActionPropertiesSerializer;
+exports.storageTaskPreviewActionPropertiesDeserializer = storageTaskPreviewActionPropertiesDeserializer;
+exports.storageTaskPreviewContainerPropertiesSerializer = storageTaskPreviewContainerPropertiesSerializer;
+exports.storageTaskPreviewContainerPropertiesDeserializer = storageTaskPreviewContainerPropertiesDeserializer;
+exports.storageTaskPreviewKeyValuePropertiesArraySerializer = storageTaskPreviewKeyValuePropertiesArraySerializer;
+exports.storageTaskPreviewKeyValuePropertiesArrayDeserializer = storageTaskPreviewKeyValuePropertiesArrayDeserializer;
+exports.storageTaskPreviewKeyValuePropertiesSerializer = storageTaskPreviewKeyValuePropertiesSerializer;
+exports.storageTaskPreviewKeyValuePropertiesDeserializer = storageTaskPreviewKeyValuePropertiesDeserializer;
+exports.storageTaskPreviewBlobPropertiesArraySerializer = storageTaskPreviewBlobPropertiesArraySerializer;
+exports.storageTaskPreviewBlobPropertiesArrayDeserializer = storageTaskPreviewBlobPropertiesArrayDeserializer;
+exports.storageTaskPreviewBlobPropertiesSerializer = storageTaskPreviewBlobPropertiesSerializer;
+exports.storageTaskPreviewBlobPropertiesDeserializer = storageTaskPreviewBlobPropertiesDeserializer;
+exports.storageTaskPreviewActionConditionSerializer = storageTaskPreviewActionConditionSerializer;
+exports.storageTaskPreviewActionConditionDeserializer = storageTaskPreviewActionConditionDeserializer;
+exports.storageTaskPreviewActionIfConditionSerializer = storageTaskPreviewActionIfConditionSerializer;
+exports.storageTaskPreviewActionIfConditionDeserializer = storageTaskPreviewActionIfConditionDeserializer;
+exports._storageTaskReportSummaryDeserializer = _storageTaskReportSummaryDeserializer;
+exports.storageTaskReportInstanceArrayDeserializer = storageTaskReportInstanceArrayDeserializer;
+exports.storageTaskReportInstanceDeserializer = storageTaskReportInstanceDeserializer;
+exports.storageTaskReportPropertiesDeserializer = storageTaskReportPropertiesDeserializer;
+exports.proxyResourceDeserializer = proxyResourceDeserializer;
+exports._storageTaskAssignmentsListResultDeserializer = _storageTaskAssignmentsListResultDeserializer;
+exports.storageTaskAssignmentArrayDeserializer = storageTaskAssignmentArrayDeserializer;
+exports.storageTaskAssignmentDeserializer = storageTaskAssignmentDeserializer;
+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"],
+    };
+}
+function storageTaskSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        identity: managedServiceIdentitySerializer(item["identity"]),
+        properties: storageTaskPropertiesSerializer(item["properties"]),
+    };
+}
+function storageTaskDeserializer(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"]),
+        identity: managedServiceIdentityDeserializer(item["identity"]),
+        properties: storageTaskPropertiesDeserializer(item["properties"]),
+    };
+}
+function managedServiceIdentitySerializer(item) {
+    return {
+        type: item["type"],
+        userAssignedIdentities: item["userAssignedIdentities"],
+    };
+}
+function managedServiceIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        tenantId: item["tenantId"],
+        type: item["type"],
+        userAssignedIdentities: item["userAssignedIdentities"],
+    };
+}
+/** Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). */
+var KnownManagedServiceIdentityType;
+(function (KnownManagedServiceIdentityType) {
+    /** No managed identity. */
+    KnownManagedServiceIdentityType["None"] = "None";
+    /** System assigned managed identity. */
+    KnownManagedServiceIdentityType["SystemAssigned"] = "SystemAssigned";
+    /** User assigned managed identity. */
+    KnownManagedServiceIdentityType["UserAssigned"] = "UserAssigned";
+    /** System and user assigned managed identity. */
+    KnownManagedServiceIdentityType["SystemAssignedUserAssigned"] = "SystemAssigned,UserAssigned";
+})(KnownManagedServiceIdentityType || (exports.KnownManagedServiceIdentityType = KnownManagedServiceIdentityType = {}));
+function userAssignedIdentitySerializer(item) {
+    return item;
+}
+function userAssignedIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        clientId: item["clientId"],
+    };
+}
+function storageTaskPropertiesSerializer(item) {
+    return {
+        enabled: item["enabled"],
+        description: item["description"],
+        action: storageTaskActionSerializer(item["action"]),
+    };
+}
+function storageTaskPropertiesDeserializer(item) {
+    return {
+        taskVersion: item["taskVersion"],
+        enabled: item["enabled"],
+        description: item["description"],
+        action: storageTaskActionDeserializer(item["action"]),
+        provisioningState: item["provisioningState"],
+        creationTimeInUtc: !item["creationTimeInUtc"]
+            ? item["creationTimeInUtc"]
+            : new Date(item["creationTimeInUtc"]),
+    };
+}
+function storageTaskActionSerializer(item) {
+    return {
+        if: ifConditionSerializer(item["if"]),
+        else: !item["else"] ? item["else"] : elseConditionSerializer(item["else"]),
+    };
+}
+function storageTaskActionDeserializer(item) {
+    return {
+        if: ifConditionDeserializer(item["if"]),
+        else: !item["else"] ? item["else"] : elseConditionDeserializer(item["else"]),
+    };
+}
+function ifConditionSerializer(item) {
+    return {
+        condition: item["condition"],
+        operations: storageTaskOperationArraySerializer(item["operations"]),
+    };
+}
+function ifConditionDeserializer(item) {
+    return {
+        condition: item["condition"],
+        operations: storageTaskOperationArrayDeserializer(item["operations"]),
+    };
+}
+function storageTaskOperationArraySerializer(result) {
+    return result.map((item) => {
+        return storageTaskOperationSerializer(item);
+    });
+}
+function storageTaskOperationArrayDeserializer(result) {
+    return result.map((item) => {
+        return storageTaskOperationDeserializer(item);
+    });
+}
+function storageTaskOperationSerializer(item) {
+    return {
+        name: item["name"],
+        parameters: item["parameters"],
+        onSuccess: item["onSuccess"],
+        onFailure: item["onFailure"],
+    };
+}
+function storageTaskOperationDeserializer(item) {
+    return {
+        name: item["name"],
+        parameters: item["parameters"],
+        onSuccess: item["onSuccess"],
+        onFailure: item["onFailure"],
+    };
+}
+/** The operation to be performed on the object. */
+var KnownStorageTaskOperationName;
+(function (KnownStorageTaskOperationName) {
+    KnownStorageTaskOperationName["SetBlobTier"] = "SetBlobTier";
+    KnownStorageTaskOperationName["SetBlobTags"] = "SetBlobTags";
+    KnownStorageTaskOperationName["SetBlobImmutabilityPolicy"] = "SetBlobImmutabilityPolicy";
+    KnownStorageTaskOperationName["SetBlobLegalHold"] = "SetBlobLegalHold";
+    KnownStorageTaskOperationName["SetBlobExpiry"] = "SetBlobExpiry";
+    KnownStorageTaskOperationName["DeleteBlob"] = "DeleteBlob";
+    KnownStorageTaskOperationName["UndeleteBlob"] = "UndeleteBlob";
+})(KnownStorageTaskOperationName || (exports.KnownStorageTaskOperationName = KnownStorageTaskOperationName = {}));
+/** Action to be taken when the operation is successful for a object. */
+var KnownOnSuccess;
+(function (KnownOnSuccess) {
+    KnownOnSuccess["Continue"] = "continue";
+})(KnownOnSuccess || (exports.KnownOnSuccess = KnownOnSuccess = {}));
+/** Action to be taken when the operation fails for a object. */
+var KnownOnFailure;
+(function (KnownOnFailure) {
+    KnownOnFailure["Break"] = "break";
+})(KnownOnFailure || (exports.KnownOnFailure = KnownOnFailure = {}));
+function elseConditionSerializer(item) {
+    return {
+        operations: storageTaskOperationArraySerializer(item["operations"]),
+    };
+}
+function elseConditionDeserializer(item) {
+    return {
+        operations: storageTaskOperationArrayDeserializer(item["operations"]),
+    };
+}
+/** Represents the provisioning state of the storage task. */
+var KnownProvisioningState;
+(function (KnownProvisioningState) {
+    KnownProvisioningState["ValidateSubscriptionQuotaBegin"] = "ValidateSubscriptionQuotaBegin";
+    KnownProvisioningState["ValidateSubscriptionQuotaEnd"] = "ValidateSubscriptionQuotaEnd";
+    KnownProvisioningState["Accepted"] = "Accepted";
+    KnownProvisioningState["Creating"] = "Creating";
+    KnownProvisioningState["Succeeded"] = "Succeeded";
+    KnownProvisioningState["Deleting"] = "Deleting";
+    KnownProvisioningState["Canceled"] = "Canceled";
+    KnownProvisioningState["Failed"] = "Failed";
+})(KnownProvisioningState || (exports.KnownProvisioningState = KnownProvisioningState = {}));
+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 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 storageTaskUpdateParametersSerializer(item) {
+    return {
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentitySerializer(item["identity"]),
+        tags: item["tags"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : storageTaskUpdatePropertiesSerializer(item["properties"]),
+    };
+}
+function storageTaskUpdatePropertiesSerializer(item) {
+    return {
+        enabled: item["enabled"],
+        description: item["description"],
+        action: !item["action"] ? item["action"] : storageTaskActionSerializer(item["action"]),
+    };
+}
+function _storageTasksListResultDeserializer(item) {
+    return {
+        value: storageTaskArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function storageTaskArraySerializer(result) {
+    return result.map((item) => {
+        return storageTaskSerializer(item);
+    });
+}
+function storageTaskArrayDeserializer(result) {
+    return result.map((item) => {
+        return storageTaskDeserializer(item);
+    });
+}
+function storageTaskPreviewActionSerializer(item) {
+    return {
+        properties: storageTaskPreviewActionPropertiesSerializer(item["properties"]),
+    };
+}
+function storageTaskPreviewActionDeserializer(item) {
+    return {
+        properties: storageTaskPreviewActionPropertiesDeserializer(item["properties"]),
+    };
+}
+function storageTaskPreviewActionPropertiesSerializer(item) {
+    return {
+        container: storageTaskPreviewContainerPropertiesSerializer(item["container"]),
+        blobs: storageTaskPreviewBlobPropertiesArraySerializer(item["blobs"]),
+        action: storageTaskPreviewActionConditionSerializer(item["action"]),
+    };
+}
+function storageTaskPreviewActionPropertiesDeserializer(item) {
+    return {
+        container: storageTaskPreviewContainerPropertiesDeserializer(item["container"]),
+        blobs: storageTaskPreviewBlobPropertiesArrayDeserializer(item["blobs"]),
+        action: storageTaskPreviewActionConditionDeserializer(item["action"]),
+    };
+}
+function storageTaskPreviewContainerPropertiesSerializer(item) {
+    return {
+        name: item["name"],
+        metadata: !item["metadata"]
+            ? item["metadata"]
+            : storageTaskPreviewKeyValuePropertiesArraySerializer(item["metadata"]),
+    };
+}
+function storageTaskPreviewContainerPropertiesDeserializer(item) {
+    return {
+        name: item["name"],
+        metadata: !item["metadata"]
+            ? item["metadata"]
+            : storageTaskPreviewKeyValuePropertiesArrayDeserializer(item["metadata"]),
+    };
+}
+function storageTaskPreviewKeyValuePropertiesArraySerializer(result) {
+    return result.map((item) => {
+        return storageTaskPreviewKeyValuePropertiesSerializer(item);
+    });
+}
+function storageTaskPreviewKeyValuePropertiesArrayDeserializer(result) {
+    return result.map((item) => {
+        return storageTaskPreviewKeyValuePropertiesDeserializer(item);
+    });
+}
+function storageTaskPreviewKeyValuePropertiesSerializer(item) {
+    return { key: item["key"], value: item["value"] };
+}
+function storageTaskPreviewKeyValuePropertiesDeserializer(item) {
+    return {
+        key: item["key"],
+        value: item["value"],
+    };
+}
+function storageTaskPreviewBlobPropertiesArraySerializer(result) {
+    return result.map((item) => {
+        return storageTaskPreviewBlobPropertiesSerializer(item);
+    });
+}
+function storageTaskPreviewBlobPropertiesArrayDeserializer(result) {
+    return result.map((item) => {
+        return storageTaskPreviewBlobPropertiesDeserializer(item);
+    });
+}
+function storageTaskPreviewBlobPropertiesSerializer(item) {
+    return {
+        name: item["name"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : storageTaskPreviewKeyValuePropertiesArraySerializer(item["properties"]),
+        metadata: !item["metadata"]
+            ? item["metadata"]
+            : storageTaskPreviewKeyValuePropertiesArraySerializer(item["metadata"]),
+        tags: !item["tags"]
+            ? item["tags"]
+            : storageTaskPreviewKeyValuePropertiesArraySerializer(item["tags"]),
+    };
+}
+function storageTaskPreviewBlobPropertiesDeserializer(item) {
+    return {
+        name: item["name"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : storageTaskPreviewKeyValuePropertiesArrayDeserializer(item["properties"]),
+        metadata: !item["metadata"]
+            ? item["metadata"]
+            : storageTaskPreviewKeyValuePropertiesArrayDeserializer(item["metadata"]),
+        tags: !item["tags"]
+            ? item["tags"]
+            : storageTaskPreviewKeyValuePropertiesArrayDeserializer(item["tags"]),
+        matchedBlock: item["matchedBlock"],
+    };
+}
+/** Represents the condition block name that matched blob properties. */
+var KnownMatchedBlockName;
+(function (KnownMatchedBlockName) {
+    KnownMatchedBlockName["If"] = "If";
+    KnownMatchedBlockName["Else"] = "Else";
+    KnownMatchedBlockName["None"] = "None";
+})(KnownMatchedBlockName || (exports.KnownMatchedBlockName = KnownMatchedBlockName = {}));
+function storageTaskPreviewActionConditionSerializer(item) {
+    return {
+        if: storageTaskPreviewActionIfConditionSerializer(item["if"]),
+        elseBlockExists: item["elseBlockExists"],
+    };
+}
+function storageTaskPreviewActionConditionDeserializer(item) {
+    return {
+        if: storageTaskPreviewActionIfConditionDeserializer(item["if"]),
+        elseBlockExists: item["elseBlockExists"],
+    };
+}
+function storageTaskPreviewActionIfConditionSerializer(item) {
+    return { condition: item["condition"] };
+}
+function storageTaskPreviewActionIfConditionDeserializer(item) {
+    return {
+        condition: item["condition"],
+    };
+}
+function _storageTaskReportSummaryDeserializer(item) {
+    return {
+        value: storageTaskReportInstanceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function storageTaskReportInstanceArrayDeserializer(result) {
+    return result.map((item) => {
+        return storageTaskReportInstanceDeserializer(item);
+    });
+}
+function storageTaskReportInstanceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : storageTaskReportPropertiesDeserializer(item["properties"]),
+    };
+}
+function storageTaskReportPropertiesDeserializer(item) {
+    return {
+        taskAssignmentId: item["taskAssignmentId"],
+        storageAccountId: item["storageAccountId"],
+        startTime: item["startTime"],
+        finishTime: item["finishTime"],
+        objectsTargetedCount: item["objectsTargetedCount"],
+        objectsOperatedOnCount: item["objectsOperatedOnCount"],
+        objectFailedCount: item["objectFailedCount"],
+        objectsSucceededCount: item["objectsSucceededCount"],
+        runStatusError: item["runStatusError"],
+        runStatusEnum: item["runStatusEnum"],
+        summaryReportPath: item["summaryReportPath"],
+        taskId: item["taskId"],
+        taskVersion: item["taskVersion"],
+        runResult: item["runResult"],
+    };
+}
+/** Represents the status of the execution. */
+var KnownRunStatusEnum;
+(function (KnownRunStatusEnum) {
+    KnownRunStatusEnum["InProgress"] = "InProgress";
+    KnownRunStatusEnum["Finished"] = "Finished";
+})(KnownRunStatusEnum || (exports.KnownRunStatusEnum = KnownRunStatusEnum = {}));
+/** Represents the overall result of the execution for the run instance */
+var KnownRunResult;
+(function (KnownRunResult) {
+    KnownRunResult["Succeeded"] = "Succeeded";
+    KnownRunResult["Failed"] = "Failed";
+})(KnownRunResult || (exports.KnownRunResult = KnownRunResult = {}));
+function proxyResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+function _storageTaskAssignmentsListResultDeserializer(item) {
+    return {
+        value: storageTaskAssignmentArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function storageTaskAssignmentArrayDeserializer(result) {
+    return result.map((item) => {
+        return storageTaskAssignmentDeserializer(item);
+    });
+}
+function storageTaskAssignmentDeserializer(item) {
+    return {
+        id: item["id"],
+    };
+}
+/** The available API versions. */
+var KnownVersions;
+(function (KnownVersions) {
+    /** The 2023-01-01 API version. */
+    KnownVersions["V20230101"] = "2023-01-01";
+})(KnownVersions || (exports.KnownVersions = KnownVersions = {}));
+//# sourceMappingURL=models.js.map