/*
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for
 * license information.
 *
 * Code generated by Microsoft (R) AutoRest Code Generator.
 * Changes may cause incorrect behavior and will be lost if the code is
 * regenerated.
 */

'use strict';

const models = require('./index');

/**
 * Contains information about a pool.
 *
 * @extends models['ProxyResource']
 */
class Pool extends models['ProxyResource'] {
  /**
   * Create a Pool.
   * @property {string} [displayName] The display name for the pool. The
   * display name need not be unique and can contain any Unicode characters up
   * to a maximum length of 1024.
   * @property {date} [lastModified] The last modified time of the pool. This
   * is the last time at which the pool level data, such as the
   * targetDedicatedNodes or autoScaleSettings, changed. It does not factor in
   * node-level changes such as a compute node changing state.
   * @property {date} [creationTime] The creation time of the pool.
   * @property {string} [provisioningState] The current state of the pool.
   * Possible values include: 'Succeeded', 'Deleting'
   * @property {date} [provisioningStateTransitionTime] The time at which the
   * pool entered its current state.
   * @property {string} [allocationState] Whether the pool is resizing.
   * Possible values include: 'Steady', 'Resizing', 'Stopping'
   * @property {date} [allocationStateTransitionTime] The time at which the
   * pool entered its current allocation state.
   * @property {string} [vmSize] The size of virtual machines in the pool. All
   * VMs in a pool are the same size. For information about available sizes of
   * virtual machines for Cloud Services pools (pools created with
   * cloudServiceConfiguration), see Sizes for Cloud Services
   * (https://azure.microsoft.com/documentation/articles/cloud-services-sizes-specs/).
   * Batch supports all Cloud Services VM sizes except ExtraSmall. For
   * information about available VM sizes for pools using images from the
   * Virtual Machines Marketplace (pools created with
   * virtualMachineConfiguration) see Sizes for Virtual Machines (Linux)
   * (https://azure.microsoft.com/documentation/articles/virtual-machines-linux-sizes/)
   * or Sizes for Virtual Machines (Windows)
   * (https://azure.microsoft.com/documentation/articles/virtual-machines-windows-sizes/).
   * Batch supports all Azure VM sizes except STANDARD_A0 and those with
   * premium storage (STANDARD_GS, STANDARD_DS, and STANDARD_DSV2 series).
   * @property {object} [deploymentConfiguration] This property describes how
   * the pool nodes will be deployed - using Cloud Services or Virtual
   * Machines. Using CloudServiceConfiguration specifies that the nodes should
   * be creating using Azure Cloud Services (PaaS), while
   * VirtualMachineConfiguration uses Azure Virtual Machines (IaaS).
   * @property {object} [deploymentConfiguration.cloudServiceConfiguration]
   * This property and virtualMachineConfiguration are mutually exclusive and
   * one of the properties must be specified. This property cannot be specified
   * if the Batch account was created with its poolAllocationMode property set
   * to 'UserSubscription'.
   * @property {string}
   * [deploymentConfiguration.cloudServiceConfiguration.osFamily] Possible
   * values are: 2 - OS Family 2, equivalent to Windows Server 2008 R2 SP1. 3 -
   * OS Family 3, equivalent to Windows Server 2012. 4 - OS Family 4,
   * equivalent to Windows Server 2012 R2. 5 - OS Family 5, equivalent to
   * Windows Server 2016. 6 - OS Family 6, equivalent to Windows Server 2019.
   * For more information, see Azure Guest OS Releases
   * (https://azure.microsoft.com/documentation/articles/cloud-services-guestos-update-matrix/#releases).
   * @property {string}
   * [deploymentConfiguration.cloudServiceConfiguration.osVersion] The default
   * value is * which specifies the latest operating system version for the
   * specified OS family.
   * @property {object} [deploymentConfiguration.virtualMachineConfiguration]
   * This property and cloudServiceConfiguration are mutually exclusive and one
   * of the properties must be specified.
   * @property {object}
   * [deploymentConfiguration.virtualMachineConfiguration.imageReference]
   * @property {string}
   * [deploymentConfiguration.virtualMachineConfiguration.imageReference.publisher]
   * For example, Canonical or MicrosoftWindowsServer.
   * @property {string}
   * [deploymentConfiguration.virtualMachineConfiguration.imageReference.offer]
   * For example, UbuntuServer or WindowsServer.
   * @property {string}
   * [deploymentConfiguration.virtualMachineConfiguration.imageReference.sku]
   * For example, 18.04-LTS or 2019-Datacenter.
   * @property {string}
   * [deploymentConfiguration.virtualMachineConfiguration.imageReference.version]
   * A value of 'latest' can be specified to select the latest version of an
   * image. If omitted, the default is 'latest'.
   * @property {string}
   * [deploymentConfiguration.virtualMachineConfiguration.imageReference.id]
   * This property is mutually exclusive with other properties. The Shared
   * Image Gallery image must have replicas in the same region as the Azure
   * Batch account. For information about the firewall settings for the Batch
   * node agent to communicate with the Batch service see
   * https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration.
   * @property {string}
   * [deploymentConfiguration.virtualMachineConfiguration.nodeAgentSkuId] The
   * Batch node agent is a program that runs on each node in the pool, and
   * provides the command-and-control interface between the node and the Batch
   * service. There are different implementations of the node agent, known as
   * SKUs, for different operating systems. You must specify a node agent SKU
   * which matches the selected image reference. To get the list of supported
   * node agent SKUs along with their list of verified image references, see
   * the 'List supported node agent SKUs' operation.
   * @property {object}
   * [deploymentConfiguration.virtualMachineConfiguration.windowsConfiguration]
   * This property must not be specified if the imageReference specifies a
   * Linux OS image.
   * @property {boolean}
   * [deploymentConfiguration.virtualMachineConfiguration.windowsConfiguration.enableAutomaticUpdates]
   * If omitted, the default value is true.
   * @property {array}
   * [deploymentConfiguration.virtualMachineConfiguration.dataDisks] This
   * property must be specified if the compute nodes in the pool need to have
   * empty data disks attached to them.
   * @property {string}
   * [deploymentConfiguration.virtualMachineConfiguration.licenseType] This
   * only applies to images that contain the Windows operating system, and
   * should only be used when you hold valid on-premises licenses for the nodes
   * which will be deployed. If omitted, no on-premises licensing discount is
   * applied. Values are:
   *
   * Windows_Server - The on-premises license is for Windows Server.
   * Windows_Client - The on-premises license is for Windows Client.
   * @property {object}
   * [deploymentConfiguration.virtualMachineConfiguration.containerConfiguration]
   * If specified, setup is performed on each node in the pool to allow tasks
   * to run in containers. All regular tasks and job manager tasks run on this
   * pool must specify the containerSettings property, and all other tasks may
   * specify it.
   * @property {array}
   * [deploymentConfiguration.virtualMachineConfiguration.containerConfiguration.containerImageNames]
   * This is the full image reference, as would be specified to "docker pull".
   * An image will be sourced from the default Docker registry unless the image
   * is fully qualified with an alternative registry.
   * @property {array}
   * [deploymentConfiguration.virtualMachineConfiguration.containerConfiguration.containerRegistries]
   * If any images must be downloaded from a private registry which requires
   * credentials, then those credentials must be provided here.
   * @property {object}
   * [deploymentConfiguration.virtualMachineConfiguration.diskEncryptionConfiguration]
   * If specified, encryption is performed on each node in the pool during node
   * provisioning.
   * @property {array}
   * [deploymentConfiguration.virtualMachineConfiguration.diskEncryptionConfiguration.targets]
   * On Linux pool, only "TemporaryDisk" is supported; on Windows pool,
   * "OsDisk" and "TemporaryDisk" must be specified.
   * @property {number} [currentDedicatedNodes] The number of compute nodes
   * currently in the pool.
   * @property {number} [currentLowPriorityNodes] The number of low priority
   * compute nodes currently in the pool.
   * @property {object} [scaleSettings] Settings which configure the number of
   * nodes in the pool.
   * @property {object} [scaleSettings.fixedScale] This property and autoScale
   * are mutually exclusive and one of the properties must be specified.
   * @property {moment.duration} [scaleSettings.fixedScale.resizeTimeout] The
   * default value is 15 minutes. Timeout values use ISO 8601 format. For
   * example, use PT10M for 10 minutes. The minimum value is 5 minutes. If you
   * specify a value less than 5 minutes, the Batch service rejects the request
   * with an error; if you are calling the REST API directly, the HTTP status
   * code is 400 (Bad Request).
   * @property {number} [scaleSettings.fixedScale.targetDedicatedNodes] At
   * least one of targetDedicatedNodes, targetLowPriorityNodes must be set.
   * @property {number} [scaleSettings.fixedScale.targetLowPriorityNodes] At
   * least one of targetDedicatedNodes, targetLowPriorityNodes must be set.
   * @property {string} [scaleSettings.fixedScale.nodeDeallocationOption] If
   * omitted, the default value is Requeue. Possible values include: 'Requeue',
   * 'Terminate', 'TaskCompletion', 'RetainedData'
   * @property {object} [scaleSettings.autoScale] This property and fixedScale
   * are mutually exclusive and one of the properties must be specified.
   * @property {string} [scaleSettings.autoScale.formula]
   * @property {moment.duration} [scaleSettings.autoScale.evaluationInterval]
   * If omitted, the default value is 15 minutes (PT15M).
   * @property {object} [autoScaleRun] The results and errors from the last
   * execution of the autoscale formula. This property is set only if the pool
   * automatically scales, i.e. autoScaleSettings are used.
   * @property {date} [autoScaleRun.evaluationTime]
   * @property {string} [autoScaleRun.results] Each variable value is returned
   * in the form $variable=value, and variables are separated by semicolons.
   * @property {object} [autoScaleRun.error]
   * @property {string} [autoScaleRun.error.code] An identifier for the error.
   * Codes are invariant and are intended to be consumed programmatically.
   * @property {string} [autoScaleRun.error.message] A message describing the
   * error, intended to be suitable for display in a user interface.
   * @property {array} [autoScaleRun.error.details]
   * @property {string} [interNodeCommunication] Whether the pool permits
   * direct communication between nodes. This imposes restrictions on which
   * nodes can be assigned to the pool. Enabling this value can reduce the
   * chance of the requested number of nodes to be allocated in the pool. If
   * not specified, this value defaults to 'Disabled'. Possible values include:
   * 'Enabled', 'Disabled'
   * @property {object} [networkConfiguration] The network configuration for
   * the pool.
   * @property {string} [networkConfiguration.subnetId] The virtual network
   * must be in the same region and subscription as the Azure Batch account.
   * The specified subnet should have enough free IP addresses to accommodate
   * the number of nodes in the pool. If the subnet doesn't have enough free IP
   * addresses, the pool will partially allocate compute nodes and a resize
   * error will occur. The 'MicrosoftAzureBatch' service principal must have
   * the 'Classic Virtual Machine Contributor' Role-Based Access Control (RBAC)
   * role for the specified VNet. The specified subnet must allow communication
   * from the Azure Batch service to be able to schedule tasks on the compute
   * nodes. This can be verified by checking if the specified VNet has any
   * associated Network Security Groups (NSG). If communication to the compute
   * nodes in the specified subnet is denied by an NSG, then the Batch service
   * will set the state of the compute nodes to unusable. If the specified VNet
   * has any associated Network Security Groups (NSG), then a few reserved
   * system ports must be enabled for inbound communication. For pools created
   * with a virtual machine configuration, enable ports 29876 and 29877, as
   * well as port 22 for Linux and port 3389 for Windows. For pools created
   * with a cloud service configuration, enable ports 10100, 20100, and 30100.
   * Also enable outbound connections to Azure Storage on port 443. For
   * cloudServiceConfiguration pools, only 'classic' VNETs are supported. For
   * more details see:
   * https://docs.microsoft.com/en-us/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
   * @property {object} [networkConfiguration.endpointConfiguration] Pool
   * endpoint configuration is only supported on pools with the
   * virtualMachineConfiguration property.
   * @property {array}
   * [networkConfiguration.endpointConfiguration.inboundNatPools] The maximum
   * number of inbound NAT pools per Batch pool is 5. If the maximum number of
   * inbound NAT pools is exceeded the request fails with HTTP status code 400.
   * @property {object} [networkConfiguration.publicIPAddressConfiguration]
   * This property is only supported on Pools with the
   * virtualMachineConfiguration property.
   * @property {string}
   * [networkConfiguration.publicIPAddressConfiguration.provision] The default
   * value is BatchManaged. Possible values include: 'BatchManaged',
   * 'UserManaged', 'NoPublicIPAddresses'
   * @property {array}
   * [networkConfiguration.publicIPAddressConfiguration.ipAddressIds] The
   * number of IPs specified here limits the maximum size of the Pool - 50
   * dedicated nodes or 20 low-priority nodes can be allocated for each public
   * IP. For example, a pool needing 150 dedicated VMs would need at least 3
   * public IPs specified. Each element of this collection is of the form:
   * /subscriptions/{subscription}/resourceGroups/{group}/providers/Microsoft.Network/publicIPAddresses/{ip}.
   * @property {number} [maxTasksPerNode] The maximum number of tasks that can
   * run concurrently on a single compute node in the pool. The default value
   * is 1. The maximum value is the smaller of 4 times the number of cores of
   * the vmSize of the pool or 256.
   * @property {object} [taskSchedulingPolicy] How tasks are distributed across
   * compute nodes in a pool. If not specified, the default is spread.
   * @property {string} [taskSchedulingPolicy.nodeFillType] Possible values
   * include: 'Spread', 'Pack'
   * @property {array} [userAccounts] The list of user accounts to be created
   * on each node in the pool.
   * @property {array} [metadata] A list of name-value pairs associated with
   * the pool as metadata. The Batch service does not assign any meaning to
   * metadata; it is solely for the use of user code.
   * @property {object} [startTask] A task specified to run on each compute
   * node as it joins the pool. In an PATCH (update) operation, this property
   * can be set to an empty object to remove the start task from the pool.
   * @property {string} [startTask.commandLine] The command line does not run
   * under a shell, and therefore cannot take advantage of shell features such
   * as environment variable expansion. If you want to take advantage of such
   * features, you should invoke the shell in the command line, for example
   * using "cmd /c MyCommand" in Windows or "/bin/sh -c MyCommand" in Linux.
   * Required if any other properties of the startTask are specified.
   * @property {array} [startTask.resourceFiles]
   * @property {array} [startTask.environmentSettings]
   * @property {object} [startTask.userIdentity] If omitted, the task runs as a
   * non-administrative user unique to the task.
   * @property {string} [startTask.userIdentity.userName] The userName and
   * autoUser properties are mutually exclusive; you must specify one but not
   * both.
   * @property {object} [startTask.userIdentity.autoUser] The userName and
   * autoUser properties are mutually exclusive; you must specify one but not
   * both.
   * @property {string} [startTask.userIdentity.autoUser.scope] The default
   * value is Pool. If the pool is running Windows a value of Task should be
   * specified if stricter isolation between tasks is required. For example, if
   * the task mutates the registry in a way which could impact other tasks, or
   * if certificates have been specified on the pool which should not be
   * accessible by normal tasks but should be accessible by start tasks.
   * Possible values include: 'Task', 'Pool'
   * @property {string} [startTask.userIdentity.autoUser.elevationLevel] The
   * default value is nonAdmin. Possible values include: 'NonAdmin', 'Admin'
   * @property {number} [startTask.maxTaskRetryCount] The Batch service retries
   * a task if its exit code is nonzero. Note that this value specifically
   * controls the number of retries. The Batch service will try the task once,
   * and may then retry up to this limit. For example, if the maximum retry
   * count is 3, Batch tries the task up to 4 times (one initial try and 3
   * retries). If the maximum retry count is 0, the Batch service does not
   * retry the task. If the maximum retry count is -1, the Batch service
   * retries the task without limit.
   * @property {boolean} [startTask.waitForSuccess] If true and the start task
   * fails on a compute node, the Batch service retries the start task up to
   * its maximum retry count (maxTaskRetryCount). If the task has still not
   * completed successfully after all retries, then the Batch service marks the
   * compute node unusable, and will not schedule tasks to it. This condition
   * can be detected via the node state and scheduling error detail. If false,
   * the Batch service will not wait for the start task to complete. In this
   * case, other tasks can start executing on the compute node while the start
   * task is still running; and even if the start task fails, new tasks will
   * continue to be scheduled on the node. The default is true.
   * @property {object} [startTask.containerSettings] When this is specified,
   * all directories recursively below the AZ_BATCH_NODE_ROOT_DIR (the root of
   * Azure Batch directories on the node) are mapped into the container, all
   * task environment variables are mapped into the container, and the task
   * command line is executed in the container.
   * @property {string} [startTask.containerSettings.containerRunOptions] These
   * additional options are supplied as arguments to the "docker create"
   * command, in addition to those controlled by the Batch Service.
   * @property {string} [startTask.containerSettings.imageName] This is the
   * full image reference, as would be specified to "docker pull". If no tag is
   * provided as part of the image name, the tag ":latest" is used as a
   * default.
   * @property {object} [startTask.containerSettings.registry] This setting can
   * be omitted if was already provided at pool creation.
   * @property {string} [startTask.containerSettings.registry.registryServer]
   * If omitted, the default is "docker.io".
   * @property {string} [startTask.containerSettings.registry.userName]
   * @property {string} [startTask.containerSettings.registry.password]
   * @property {string} [startTask.containerSettings.workingDirectory] Possible
   * values include: 'TaskWorkingDirectory', 'ContainerImageDefault'
   * @property {array} [certificates] The list of certificates to be installed
   * on each compute node in the pool. For Windows compute nodes, the Batch
   * service installs the certificates to the specified certificate store and
   * location. For Linux compute nodes, the certificates are stored in a
   * directory inside the task working directory and an environment variable
   * AZ_BATCH_CERTIFICATES_DIR is supplied to the task to query for this
   * location. For certificates with visibility of 'remoteUser', a 'certs'
   * directory is created in the user's home directory (e.g.,
   * /home/{user-name}/certs) and certificates are placed in that directory.
   * @property {array} [applicationPackages] The list of application packages
   * to be installed on each compute node in the pool. Changes to application
   * package references affect all new compute nodes joining the pool, but do
   * not affect compute nodes that are already in the pool until they are
   * rebooted or reimaged. There is a maximum of 10 application package
   * references on any given pool.
   * @property {array} [applicationLicenses] The list of application licenses
   * the Batch service will make available on each compute node in the pool.
   * The list of application licenses must be a subset of available Batch
   * service application licenses. If a license is requested which is not
   * supported, pool creation will fail.
   * @property {object} [resizeOperationStatus] Contains details about the
   * current or last completed resize operation.
   * @property {number} [resizeOperationStatus.targetDedicatedNodes]
   * @property {number} [resizeOperationStatus.targetLowPriorityNodes]
   * @property {moment.duration} [resizeOperationStatus.resizeTimeout] The
   * default value is 15 minutes. The minimum value is 5 minutes. If you
   * specify a value less than 5 minutes, the Batch service returns an error;
   * if you are calling the REST API directly, the HTTP status code is 400 (Bad
   * Request).
   * @property {string} [resizeOperationStatus.nodeDeallocationOption] The
   * default value is requeue. Possible values include: 'Requeue', 'Terminate',
   * 'TaskCompletion', 'RetainedData'
   * @property {date} [resizeOperationStatus.startTime]
   * @property {array} [resizeOperationStatus.errors] This property is set only
   * if an error occurred during the last pool resize, and only when the pool
   * allocationState is Steady.
   * @property {array} [mountConfiguration] A list of file systems to mount on
   * each node in the pool. This supports Azure Files, NFS, CIFS/SMB, and
   * Blobfuse.
   */
  constructor() {
    super();
  }

  /**
   * Defines the metadata of Pool
   *
   * @returns {object} metadata of Pool
   *
   */
  mapper() {
    return {
      required: false,
      serializedName: 'Pool',
      type: {
        name: 'Composite',
        className: 'Pool',
        modelProperties: {
          id: {
            required: false,
            readOnly: true,
            serializedName: 'id',
            type: {
              name: 'String'
            }
          },
          name: {
            required: false,
            readOnly: true,
            serializedName: 'name',
            type: {
              name: 'String'
            }
          },
          type: {
            required: false,
            readOnly: true,
            serializedName: 'type',
            type: {
              name: 'String'
            }
          },
          etag: {
            required: false,
            readOnly: true,
            serializedName: 'etag',
            type: {
              name: 'String'
            }
          },
          displayName: {
            required: false,
            serializedName: 'properties.displayName',
            type: {
              name: 'String'
            }
          },
          lastModified: {
            required: false,
            readOnly: true,
            serializedName: 'properties.lastModified',
            type: {
              name: 'DateTime'
            }
          },
          creationTime: {
            required: false,
            readOnly: true,
            serializedName: 'properties.creationTime',
            type: {
              name: 'DateTime'
            }
          },
          provisioningState: {
            required: false,
            readOnly: true,
            serializedName: 'properties.provisioningState',
            type: {
              name: 'Enum',
              allowedValues: [ 'Succeeded', 'Deleting' ]
            }
          },
          provisioningStateTransitionTime: {
            required: false,
            readOnly: true,
            serializedName: 'properties.provisioningStateTransitionTime',
            type: {
              name: 'DateTime'
            }
          },
          allocationState: {
            required: false,
            readOnly: true,
            serializedName: 'properties.allocationState',
            type: {
              name: 'Enum',
              allowedValues: [ 'Steady', 'Resizing', 'Stopping' ]
            }
          },
          allocationStateTransitionTime: {
            required: false,
            readOnly: true,
            serializedName: 'properties.allocationStateTransitionTime',
            type: {
              name: 'DateTime'
            }
          },
          vmSize: {
            required: false,
            serializedName: 'properties.vmSize',
            type: {
              name: 'String'
            }
          },
          deploymentConfiguration: {
            required: false,
            serializedName: 'properties.deploymentConfiguration',
            type: {
              name: 'Composite',
              className: 'DeploymentConfiguration'
            }
          },
          currentDedicatedNodes: {
            required: false,
            readOnly: true,
            serializedName: 'properties.currentDedicatedNodes',
            type: {
              name: 'Number'
            }
          },
          currentLowPriorityNodes: {
            required: false,
            readOnly: true,
            serializedName: 'properties.currentLowPriorityNodes',
            type: {
              name: 'Number'
            }
          },
          scaleSettings: {
            required: false,
            serializedName: 'properties.scaleSettings',
            type: {
              name: 'Composite',
              className: 'ScaleSettings'
            }
          },
          autoScaleRun: {
            required: false,
            readOnly: true,
            serializedName: 'properties.autoScaleRun',
            type: {
              name: 'Composite',
              className: 'AutoScaleRun'
            }
          },
          interNodeCommunication: {
            required: false,
            serializedName: 'properties.interNodeCommunication',
            type: {
              name: 'Enum',
              allowedValues: [ 'Enabled', 'Disabled' ]
            }
          },
          networkConfiguration: {
            required: false,
            serializedName: 'properties.networkConfiguration',
            type: {
              name: 'Composite',
              className: 'NetworkConfiguration'
            }
          },
          maxTasksPerNode: {
            required: false,
            serializedName: 'properties.maxTasksPerNode',
            type: {
              name: 'Number'
            }
          },
          taskSchedulingPolicy: {
            required: false,
            serializedName: 'properties.taskSchedulingPolicy',
            type: {
              name: 'Composite',
              className: 'TaskSchedulingPolicy'
            }
          },
          userAccounts: {
            required: false,
            serializedName: 'properties.userAccounts',
            type: {
              name: 'Sequence',
              element: {
                  required: false,
                  serializedName: 'UserAccountElementType',
                  type: {
                    name: 'Composite',
                    className: 'UserAccount'
                  }
              }
            }
          },
          metadata: {
            required: false,
            serializedName: 'properties.metadata',
            type: {
              name: 'Sequence',
              element: {
                  required: false,
                  serializedName: 'MetadataItemElementType',
                  type: {
                    name: 'Composite',
                    className: 'MetadataItem'
                  }
              }
            }
          },
          startTask: {
            required: false,
            serializedName: 'properties.startTask',
            type: {
              name: 'Composite',
              className: 'StartTask'
            }
          },
          certificates: {
            required: false,
            serializedName: 'properties.certificates',
            type: {
              name: 'Sequence',
              element: {
                  required: false,
                  serializedName: 'CertificateReferenceElementType',
                  type: {
                    name: 'Composite',
                    className: 'CertificateReference'
                  }
              }
            }
          },
          applicationPackages: {
            required: false,
            serializedName: 'properties.applicationPackages',
            type: {
              name: 'Sequence',
              element: {
                  required: false,
                  serializedName: 'ApplicationPackageReferenceElementType',
                  type: {
                    name: 'Composite',
                    className: 'ApplicationPackageReference'
                  }
              }
            }
          },
          applicationLicenses: {
            required: false,
            serializedName: 'properties.applicationLicenses',
            type: {
              name: 'Sequence',
              element: {
                  required: false,
                  serializedName: 'StringElementType',
                  type: {
                    name: 'String'
                  }
              }
            }
          },
          resizeOperationStatus: {
            required: false,
            readOnly: true,
            serializedName: 'properties.resizeOperationStatus',
            type: {
              name: 'Composite',
              className: 'ResizeOperationStatus'
            }
          },
          mountConfiguration: {
            required: false,
            serializedName: 'properties.mountConfiguration',
            type: {
              name: 'Sequence',
              element: {
                  required: false,
                  serializedName: 'MountConfigurationElementType',
                  type: {
                    name: 'Composite',
                    className: 'MountConfiguration'
                  }
              }
            }
          }
        }
      }
    };
  }
}

module.exports = Pool;
