azbatch

type AccessScope string

type AccountListSupportedImagesResult struct {
	// The URL to get the next set of results.
	NextLink *string

	// The list of supported Virtual Machine Images.
	Value []SupportedImage
}

type AddTaskCollectionResult struct {
	// The results of the add Task collection operation.
	Value []TaskAddResult
}

type AffinityInfo struct {
	// REQUIRED; An opaque string representing the location of a Compute Node or a Task that has run previously. You can pass
	// the affinityId of a Node to indicate that this Task needs to run on that Compute Node. Note that this is just a soft affinity.
	// If the target Compute Node is busy or unavailable at the time the Task is scheduled, then the Task will be scheduled elsewhere.
	AffinityID *string
}

type AllocationState string

type Application struct {
	// REQUIRED; The display name for the application.
	DisplayName *string

	// REQUIRED; A string that uniquely identifies the application within the Account.
	ID *string

	// REQUIRED; The list of available versions of the application.
	Versions []string
}

type ApplicationListResult struct {
	// The URL to get the next set of results.
	NextLink *string

	// The list of applications available in the Account.
	Value []Application
}

type ApplicationPackageReference struct {
	// REQUIRED; The ID of the application to deploy. When creating a pool, the package's application ID must be fully qualified
	// (/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/applications/{applicationName}).
	ApplicationID *string

	// The version of the application to deploy. If omitted, the default version is deployed. If this is omitted on a Pool, and
	// no default version is specified for this application, the request fails with the error code InvalidApplicationPackageReferences
	// and HTTP status code 409. If this is omitted on a Task, and no default version is specified for this application, the Task
	// fails with a pre-processing error.
	Version *string
}

type AuthenticationTokenSettings struct {
	// The Batch resources to which the token grants access. The authentication token grants access to a limited set of Batch
	// service operations. Currently the only supported value for the access property is 'job', which grants access to all operations
	// related to the Job which contains the Task.
	Access []AccessScope
}

type AutoPoolSpecification struct {
	// REQUIRED; The minimum lifetime of created auto Pools, and how multiple Jobs on a schedule are assigned to Pools.
	PoolLifetimeOption *PoolLifetimeOption

	// A prefix to be added to the unique identifier when a Pool is automatically created. The Batch service assigns each auto
	// Pool a unique identifier on creation. To distinguish between Pools created for different purposes, you can specify this
	// element to add a prefix to the ID that is assigned. The prefix can be up to 20 characters long.
	AutoPoolIDPrefix *string

	// Whether to keep an auto Pool alive after its lifetime expires. If false, the Batch service deletes the Pool once its lifetime
	// (as determined by the poolLifetimeOption setting) expires; that is, when the Job or Job Schedule completes. If true, the
	// Batch service does not delete the Pool automatically. It is up to the user to delete auto Pools created with this option.
	KeepAlive *bool

	// The Pool specification for the auto Pool.
	Pool *PoolSpecification
}

type AutoScaleRun struct {
	// REQUIRED; The time at which the autoscale formula was last evaluated.
	Timestamp *time.Time

	// Details of the error encountered evaluating the autoscale formula on the Pool, if the evaluation was unsuccessful.
	Error *AutoScaleRunError

	// The final values of all variables used in the evaluation of the autoscale formula. Each variable value is returned in the
	// form $variable=value, and variables are separated by semicolons.
	Results *string
}

type AutoScaleRunError struct {
	// An identifier for the autoscale error. Codes are invariant and are intended to be consumed programmatically.
	Code *string

	// A message describing the autoscale error, intended to be suitable for display in a user interface.
	Message *string

	// A list of additional error details related to the autoscale error.
	Values []NameValuePair
}

type AutoUserScope string

type AutoUserSpecification struct {
	// The elevation level of the auto user. The default value is nonAdmin.
	ElevationLevel *ElevationLevel

	// The scope for the auto user. 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 StartTasks.
	Scope *AutoUserScope
}

type AutomaticOSUpgradePolicy struct {
	// Whether OS image rollback feature should be disabled.
	DisableAutomaticRollback *bool

	// Indicates whether OS upgrades should automatically be applied to scale set instances in a rolling fashion when a newer
	// version of the OS image becomes available. <br /><br /> If this is set to true for Windows based pools, [WindowsConfiguration.enableAutomaticUpdates](https://learn.microsoft.com/rest/api/batchservice/pool/add?tabs=HTTP#windowsconfiguration)
	// cannot be set to true.
	EnableAutomaticOsUpgrade *bool

	// Defer OS upgrades on the TVMs if they are running tasks.
	OSRollingUpgradeDeferral *bool

	// Indicates whether rolling upgrade policy should be used during Auto OS Upgrade. Auto OS Upgrade will fallback to the default
	// policy if no policy is defined on the VMSS.
	UseRollingUpgradePolicy *bool
}

type AzureBlobFileSystemConfiguration struct {
	// REQUIRED; The Azure Storage Account name.
	AccountName *string

	// REQUIRED; The Azure Blob Storage Container name.
	ContainerName *string

	// REQUIRED; The relative path on the compute node where the file system will be mounted. All file systems are mounted relative
	// to the Batch mounts directory, accessible via the AZ_BATCH_NODE_MOUNTS_DIR environment variable.
	RelativeMountPath *string

	// The Azure Storage Account key. This property is mutually exclusive with both sasKey and identity; exactly one must be specified.
	AccountKey *string

	// Additional command line options to pass to the mount command. These are 'net use' options in Windows and 'mount' options
	// in Linux.
	BlobfuseOptions *string

	// The reference to the user assigned identity to use to access containerName. This property is mutually exclusive with both
	// accountKey and sasKey; exactly one must be specified.
	IdentityReference *NodeIdentityReference

	// The Azure Storage SAS token. This property is mutually exclusive with both accountKey and identity; exactly one must be
	// specified.
	SASKey *string
}

type AzureFileShareConfiguration struct {
	// REQUIRED; The Azure Storage account key.
	AccountKey *string

	// REQUIRED; The Azure Storage account name.
	AccountName *string

	// REQUIRED; The Azure Files URL. This is of the form 'https://{account}.file.core.windows.net/'.
	AzureFileURL *string

	// REQUIRED; The relative path on the compute node where the file system will be mounted. All file systems are mounted relative
	// to the Batch mounts directory, accessible via the AZ_BATCH_NODE_MOUNTS_DIR environment variable.
	RelativeMountPath *string

	// Additional command line options to pass to the mount command. These are 'net use' options in Windows and 'mount' options
	// in Linux.
	MountOptions *string
}

type CIFSMountConfiguration struct {
	// REQUIRED; The password to use for authentication against the CIFS file system.
	Password *string

	// REQUIRED; The relative path on the compute node where the file system will be mounted. All file systems are mounted relative
	// to the Batch mounts directory, accessible via the AZ_BATCH_NODE_MOUNTS_DIR environment variable.
	RelativeMountPath *string

	// REQUIRED; The URI of the file system to mount.
	Source *string

	// REQUIRED; The user to use for authentication against the CIFS file system.
	Username *string

	// Additional command line options to pass to the mount command. These are 'net use' options in Windows and 'mount' options
	// in Linux.
	MountOptions *string
}

type CachingType string

type CancelCertificateDeletionOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type CancelCertificateDeletionResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type Certificate struct {
	// REQUIRED; The base64-encoded contents of the Certificate. The maximum size is 10KB.
	Data *string

	// REQUIRED; The X.509 thumbprint of the Certificate. This is a sequence of up to 40 hex digits (it may include spaces but
	// these are removed).
	Thumbprint *string

	// REQUIRED; The algorithm used to derive the thumbprint. This must be sha1.
	ThumbprintAlgorithm *string

	// The format of the Certificate data.
	Format *CertificateFormat

	// The password to access the Certificate's private key. This must be omitted if the Certificate format is cer.
	Password *string

	// READ-ONLY; The error that occurred on the last attempt to delete this Certificate. This property is set only if the Certificate
	// is in the DeleteFailed state.
	DeleteCertificateError *DeleteCertificateError

	// READ-ONLY; The previous state of the Certificate. This property is not set if the Certificate is in its initial active
	// state.
	PreviousState *CertificateState

	// READ-ONLY; The time at which the Certificate entered its previous state. This property is not set if the Certificate is
	// in its initial Active state.
	PreviousStateTransitionTime *time.Time

	// READ-ONLY; The public part of the Certificate as a base-64 encoded .cer file.
	PublicData *string

	// READ-ONLY; The state of the Certificate.
	State *CertificateState

	// READ-ONLY; The time at which the Certificate entered its current state.
	StateTransitionTime *time.Time

	// READ-ONLY; The URL of the Certificate.
	URL *string
}

type CertificateFormat string

type CertificateListResult struct {
	// The URL to get the next set of results.
	NextLink *string

	// The list of Certificates.
	Value []Certificate
}

type CertificateReference struct {
	// REQUIRED; The thumbprint of the Certificate.
	Thumbprint *string

	// REQUIRED; The algorithm with which the thumbprint is associated. This must be sha1.
	ThumbprintAlgorithm *string

	// The location of the Certificate store on the Compute Node into which to install the Certificate. The default value is currentuser.
	// This property is applicable only for Pools configured with Windows Compute Nodes (that is, created with cloudServiceConfiguration,
	// or with virtualMachineConfiguration using a Windows Image reference). 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.
	StoreLocation *CertificateStoreLocation

	// The name of the Certificate store on the Compute Node into which to install the Certificate. This property is applicable
	// only for Pools configured with Windows Compute Nodes (that is, created with cloudServiceConfiguration, or with virtualMachineConfiguration
	// using a Windows Image reference). Common store names include: My, Root, CA, Trust, Disallowed, TrustedPeople, TrustedPublisher,
	// AuthRoot, AddressBook, but any custom store name can also be used. The default value is My.
	StoreName *string

	// Which user Accounts on the Compute Node should have access to the private data of the Certificate. You can specify more
	// than one visibility in this collection. The default is all Accounts.
	Visibility []CertificateVisibility
}

type CertificateState string

type CertificateStoreLocation string

type CertificateVisibility string

type Client struct {
	// contains filtered or unexported fields
}

type ClientOptions struct {
	azcore.ClientOptions
}

type ContainerConfiguration struct {
	// REQUIRED; The container technology to be used.
	Type *ContainerType

	// The collection of container Image names. 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.
	ContainerImageNames []string

	// Additional private registries from which containers can be pulled. If any Images must be downloaded from a private registry
	// which requires credentials, then those credentials must be provided here.
	ContainerRegistries []ContainerRegistryReference
}

type ContainerHostBindMountEntry struct {
	// Mount this source path as read-only mode or not. Default value is false (read/write mode). For Linux, if you mount this
	// path as a read/write mode, this does not mean that all users in container have the read/write access for the path, it depends
	// on the access in host VM. If this path is mounted read-only, all users within the container will not be able to modify
	// the path.
	IsReadOnly *bool

	// The path which be mounted to container customer can select.
	Source *ContainerHostDataPath
}

type ContainerHostDataPath string

type ContainerRegistryReference struct {
	// The reference to the user assigned identity to use to access an Azure Container Registry instead of username and password.
	IdentityReference *NodeIdentityReference

	// The password to log into the registry server.
	Password *string

	// The registry URL. If omitted, the default is "docker.io".
	RegistryServer *string

	// The user name to log into the registry server.
	Username *string
}

type ContainerType string

type ContainerWorkingDirectory string

type CreateCertificateOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type CreateCertificateResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type CreateJobContent struct {
	// REQUIRED; A string that uniquely identifies the Job within the Account. The ID can contain any combination of alphanumeric
	// characters including hyphens and underscores, and cannot contain more than 64 characters. The ID is case-preserving and
	// case-insensitive (that is, you may not have two IDs within an Account that differ only by case).
	ID *string

	// REQUIRED; The Pool on which the Batch service runs the Job's Tasks.
	PoolInfo *PoolInfo

	// Whether Tasks in this job can be preempted by other high priority jobs. If the value is set to True, other high priority
	// jobs submitted to the system will take precedence and will be able requeue tasks from this job. You can update a job's
	// allowTaskPreemption after it has been created using the update job API.
	AllowTaskPreemption *bool

	// The list of common environment variable settings. These environment variables are set for all Tasks in the Job (including
	// the Job Manager, Job Preparation and Job Release Tasks). Individual Tasks can override an environment setting specified
	// here by specifying the same setting name with a different value.
	CommonEnvironmentSettings []EnvironmentSetting

	// The execution constraints for the Job.
	Constraints *JobConstraints

	// The display name for the Job. The display name need not be unique and can contain any Unicode characters up to a maximum
	// length of 1024.
	DisplayName *string

	// Details of a Job Manager Task to be launched when the Job is started. If the Job does not specify a Job Manager Task, the
	// user must explicitly add Tasks to the Job. If the Job does specify a Job Manager Task, the Batch service creates the Job
	// Manager Task when the Job is created, and will try to schedule the Job Manager Task before scheduling other Tasks in the
	// Job. The Job Manager Task's typical purpose is to control and/or monitor Job execution, for example by deciding what additional
	// Tasks to run, determining when the work is complete, etc. (However, a Job Manager Task is not restricted to these activities
	// - it is a fully-fledged Task in the system and perform whatever actions are required for the Job.) For example, a Job Manager
	// Task might download a file specified as a parameter, analyze the contents of that file and submit additional Tasks based
	// on those contents.
	JobManagerTask *JobManagerTask

	// The Job Preparation Task. If a Job has a Job Preparation Task, the Batch service will run the Job Preparation Task on a
	// Node before starting any Tasks of that Job on that Compute Node.
	JobPreparationTask *JobPreparationTask

	// The Job Release Task. A Job Release Task cannot be specified without also specifying a Job Preparation Task for the Job.
	// The Batch service runs the Job Release Task on the Nodes that have run the Job Preparation Task. The primary purpose of
	// the Job Release Task is to undo changes to Compute Nodes made by the Job Preparation Task. Example activities include deleting
	// local files, or shutting down services that were started as part of Job preparation.
	JobReleaseTask *JobReleaseTask

	// The maximum number of tasks that can be executed in parallel for the job. The value of maxParallelTasks must be -1 or greater
	// than 0 if specified. If not specified, the default value is -1, which means there's no limit to the number of tasks that
	// can be run at once. You can update a job's maxParallelTasks after it has been created using the update job API.
	MaxParallelTasks *int32

	// A list of name-value pairs associated with the Job as metadata. The Batch service does not assign any meaning to metadata;
	// it is solely for the use of user code.
	Metadata []MetadataItem

	// The network configuration for the Job.
	NetworkConfiguration *JobNetworkConfiguration

	// The action the Batch service should take when all Tasks in the Job are in the completed state. Note that if a Job contains
	// no Tasks, then all Tasks are considered complete. This option is therefore most commonly used with a Job Manager task;
	// if you want to use automatic Job termination without a Job Manager, you should initially set onAllTasksComplete to noaction
	// and update the Job properties to set onAllTasksComplete to terminatejob once you have finished adding Tasks. The default
	// is noaction.
	OnAllTasksComplete *OnAllTasksComplete

	// The action the Batch service should take when any Task in the Job fails. A Task is considered to have failed if has a failureInfo.
	// A failureInfo is set if the Task completes with a non-zero exit code after exhausting its retry count, or if there was
	// an error starting the Task, for example due to a resource file download error. The default is noaction.
	OnTaskFailure *OnTaskFailure

	// The priority of the Job. Priority values can range from -1000 to 1000, with -1000 being the lowest priority and 1000 being
	// the highest priority. The default value is 0.
	Priority *int32

	// Whether Tasks in the Job can define dependencies on each other. The default is false.
	UsesTaskDependencies *bool
}

type CreateJobOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type CreateJobResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type CreateJobScheduleContent struct {
	// REQUIRED; A string that uniquely identifies the schedule within the Account. The ID can contain any combination of alphanumeric
	// characters including hyphens and underscores, and cannot contain more than 64 characters. The ID is case-preserving and
	// case-insensitive (that is, you may not have two IDs within an Account that differ only by case).
	ID *string

	// REQUIRED; The details of the Jobs to be created on this schedule.
	JobSpecification *JobSpecification

	// REQUIRED; The schedule according to which Jobs will be created. All times are fixed respective to UTC and are not impacted
	// by daylight saving time.
	Schedule *JobScheduleConfiguration

	// The display name for the schedule. The display name need not be unique and can contain any Unicode characters up to a maximum
	// length of 1024.
	DisplayName *string

	// A list of name-value pairs associated with the schedule as metadata. The Batch service does not assign any meaning to metadata;
	// it is solely for the use of user code.
	Metadata []MetadataItem
}

type CreateJobScheduleOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type CreateJobScheduleResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type CreateNodeUserContent struct {
	// REQUIRED; The user name of the Account.
	Name *string

	// The time at which the Account should expire. If omitted, the default is 1 day from the current time. For Linux Compute
	// Nodes, the expiryTime has a precision up to a day.
	ExpiryTime *time.Time

	// Whether the Account should be an administrator on the Compute Node. The default value is false.
	IsAdmin *bool

	// The password of the Account. The password is required for Windows Compute Nodes. For Linux Compute Nodes, the password
	// can optionally be specified along with the sshPublicKey property.
	Password *string

	// The SSH public key that can be used for remote login to the Compute Node. The public key should be compatible with OpenSSH
	// encoding and should be base 64 encoded. This property can be specified only for Linux Compute Nodes. If this is specified
	// for a Windows Compute Node, then the Batch service rejects the request; if you are calling the REST API directly, the HTTP
	// status code is 400 (Bad Request).
	SSHPublicKey *string
}

type CreateNodeUserOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type CreateNodeUserResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type CreatePoolContent struct {
	// REQUIRED; A string that uniquely identifies the Pool within the Account. The ID can contain any combination of alphanumeric
	// characters including hyphens and underscores, and cannot contain more than 64 characters. The ID is case-preserving and
	// case-insensitive (that is, you may not have two Pool IDs within an Account that differ only by case).
	ID *string

	// REQUIRED; The size of virtual machines in the Pool. All virtual machines in a Pool are the same size. For information about
	// available VM sizes for Pools using Images from the Virtual Machines Marketplace (pools created with virtualMachineConfiguration),
	// see Sizes for Virtual Machines in Azure (https://learn.microsoft.com/azure/virtual-machines/sizes/overview). Batch supports
	// all Azure VM sizes except STANDARD_A0 and those with premium storage (STANDARD_GS, STANDARD_DS, and STANDARD_DSV2 series).
	VMSize *string

	// The list of Packages to be installed on each Compute Node in the Pool. When creating a pool, the package's application
	// ID must be fully qualified (/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/applications/{applicationName}).
	// Changes to Package references affect all new 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 Package references on any given Pool.
	ApplicationPackageReferences []ApplicationPackageReference

	// The time interval at which to automatically adjust the Pool size according to the autoscale formula. The default value
	// is 15 minutes. The minimum and maximum value are 5 minutes and 168 hours respectively. If you specify a value less than
	// 5 minutes or greater than 168 hours, the Batch service returns an error; if you are calling the REST API directly, the
	// HTTP status code is 400 (Bad Request).
	AutoScaleEvaluationInterval *string

	// A formula for the desired number of Compute Nodes in the Pool. This property must not be specified if enableAutoScale is
	// set to false. It is required if enableAutoScale is set to true. The formula is checked for validity before the Pool is
	// created. If the formula is not valid, the Batch service rejects the request with detailed error information. For more information
	// about specifying this formula, see 'Automatically scale Compute Nodes in an Azure Batch Pool' (https://learn.microsoft.com/azure/batch/batch-automatic-scaling).
	AutoScaleFormula *string

	// For Windows 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.
	// Warning: This property is deprecated and will be removed after February, 2024. Please use the [Azure KeyVault Extension](https://learn.microsoft.com/azure/batch/batch-certificate-migration-guide)
	// instead.
	CertificateReferences []CertificateReference

	// 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.
	DisplayName *string

	// Whether the Pool size should automatically adjust over time. If false, at least one of targetDedicatedNodes and targetLowPriorityNodes
	// must be specified. If true, the autoScaleFormula property is required and the Pool automatically resizes according to the
	// formula. The default value is false.
	EnableAutoScale *bool

	// Whether the Pool permits direct communication between Compute Nodes. Enabling inter-node communication limits the maximum
	// size of the Pool due to deployment restrictions on the Compute Nodes of the Pool. This may result in the Pool not reaching
	// its desired size. The default value is false.
	EnableInterNodeCommunication *bool

	// 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.
	Metadata []MetadataItem

	// Mount storage using specified file system for the entire lifetime of the pool. Mount the storage using Azure fileshare,
	// NFS, CIFS or Blobfuse based file system.
	MountConfiguration []MountConfiguration

	// The network configuration for the Pool.
	NetworkConfiguration *NetworkConfiguration

	// The timeout for allocation of Compute Nodes to the Pool. This timeout applies only to manual scaling; it has no effect
	// when enableAutoScale is set to true. 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).
	ResizeTimeout *string

	// The user-specified tags associated with the pool. The user-defined tags to be associated with the Azure Batch Pool. When
	// specified, these tags are propagated to the backing Azure resources associated with the pool. This property can only be
	// specified when the Batch account was created with the poolAllocationMode property set to 'UserSubscription'.
	ResourceTags map[string]*string

	// A Task specified to run on each Compute Node as it joins the Pool. The Task runs when the Compute Node is added to the
	// Pool or when the Compute Node is restarted.
	StartTask *StartTask

	// The desired number of dedicated Compute Nodes in the Pool. This property must not be specified if enableAutoScale is set
	// to true. If enableAutoScale is set to false, then you must set either targetDedicatedNodes, targetLowPriorityNodes, or
	// both.
	TargetDedicatedNodes *int32

	// The desired number of Spot/Low-priority Compute Nodes in the Pool. This property must not be specified if enableAutoScale
	// is set to true. If enableAutoScale is set to false, then you must set either targetDedicatedNodes, targetLowPriorityNodes,
	// or both.
	TargetLowPriorityNodes *int32

	// The desired node communication mode for the pool. If omitted, the default value is Default.
	TargetNodeCommunicationMode *NodeCommunicationMode

	// How Tasks are distributed across Compute Nodes in a Pool. If not specified, the default is spread.
	TaskSchedulingPolicy *TaskSchedulingPolicy

	// The number of task slots that can be used to run concurrent tasks 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.
	TaskSlotsPerNode *int32

	// The upgrade policy for the Pool. Describes an upgrade policy - automatic, manual, or rolling.
	UpgradePolicy *UpgradePolicy

	// The list of user Accounts to be created on each Compute Node in the Pool.
	UserAccounts []UserAccount

	// The virtual machine configuration for the Pool. This property must be specified.
	VirtualMachineConfiguration *VirtualMachineConfiguration
}

type CreatePoolOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type CreatePoolResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type CreateTaskCollectionOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type CreateTaskCollectionResponse struct {
	// The result of adding a collection of Tasks to a Job.
	AddTaskCollectionResult

	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type CreateTaskContent struct {
	// REQUIRED; The command line of the Task. For multi-instance Tasks, the command line is executed as the primary Task, after
	// the primary Task and all subtasks have finished executing the coordination command line. 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. If the command line refers to file paths, it should use a relative path
	// (relative to the Task working directory), or use the Batch provided environment variable (https://learn.microsoft.com/azure/batch/batch-compute-node-environment-variables).
	CommandLine *string

	// REQUIRED; A string that uniquely identifies the Task within the Job. The ID can contain any combination of alphanumeric
	// characters including hyphens and underscores, and cannot contain more than 64 characters. The ID is case-preserving and
	// case-insensitive (that is, you may not have two IDs within a Job that differ only by case).
	ID *string

	// A locality hint that can be used by the Batch service to select a Compute Node on which to start the new Task.
	AffinityInfo *AffinityInfo

	// A list of Packages that the Batch service will deploy to the Compute Node before running the command line. Application
	// packages are downloaded and deployed to a shared directory, not the Task working directory. Therefore, if a referenced
	// package is already on the Node, and is up to date, then it is not re-downloaded; the existing copy on the Compute Node
	// is used. If a referenced Package cannot be installed, for example because the package has been deleted or because download
	// failed, the Task fails.
	ApplicationPackageReferences []ApplicationPackageReference

	// The settings for an authentication token that the Task can use to perform Batch service operations. If this property is
	// set, the Batch service provides the Task with an authentication token which can be used to authenticate Batch service operations
	// without requiring an Account access key. The token is provided via the AZ_BATCH_AUTHENTICATION_TOKEN environment variable.
	// The operations that the Task can carry out using the token depend on the settings. For example, a Task can request Job
	// permissions in order to add other Tasks to the Job, or check the status of the Job or of other Tasks under the Job.
	AuthenticationTokenSettings *AuthenticationTokenSettings

	// The execution constraints that apply to this Task. If you do not specify constraints, the maxTaskRetryCount is the maxTaskRetryCount
	// specified for the Job, the maxWallClockTime is infinite, and the retentionTime is 7 days.
	Constraints *TaskConstraints

	// The settings for the container under which the Task runs. If the Pool that will run this Task has containerConfiguration
	// set, this must be set as well. If the Pool that will run this Task doesn't have containerConfiguration set, this must not
	// be set. 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. Files produced in the container outside of AZ_BATCH_NODE_ROOT_DIR might not
	// be reflected to the host disk, meaning that Batch file APIs will not be able to access those files.
	ContainerSettings *TaskContainerSettings

	// The Tasks that this Task depends on. This Task will not be scheduled until all Tasks that it depends on have completed
	// successfully. If any of those Tasks fail and exhaust their retry counts, this Task will never be scheduled. If the Job
	// does not have usesTaskDependencies set to true, and this element is present, the request fails with error code TaskDependenciesNotSpecifiedOnJob.
	DependsOn *TaskDependencies

	// A display name for the Task. The display name need not be unique and can contain any Unicode characters up to a maximum
	// length of 1024.
	DisplayName *string

	// A list of environment variable settings for the Task.
	EnvironmentSettings []EnvironmentSetting

	// How the Batch service should respond when the Task completes.
	ExitConditions *ExitConditions

	// An object that indicates that the Task is a multi-instance Task, and contains information about how to run the multi-instance
	// Task.
	MultiInstanceSettings *MultiInstanceSettings

	// A list of files that the Batch service will upload from the Compute Node after running the command line. For multi-instance
	// Tasks, the files will only be uploaded from the Compute Node on which the primary Task is executed.
	OutputFiles []OutputFile

	// The number of scheduling slots that the Task required to run. The default is 1. A Task can only be scheduled to run on
	// a compute node if the node has enough free scheduling slots available. For multi-instance Tasks, this must be 1.
	RequiredSlots *int32

	// A list of files that the Batch service will download to the Compute Node before running the command line. For multi-instance
	// Tasks, the resource files will only be downloaded to the Compute Node on which the primary Task is executed. There is a
	// maximum size for the list of resource files. When the max size is exceeded, the request will fail and the response error
	// code will be RequestEntityTooLarge. If this occurs, the collection of ResourceFiles must be reduced in size. This can be
	// achieved using .zip files, Application Packages, or Docker Containers.
	ResourceFiles []ResourceFile

	// The user identity under which the Task runs. If omitted, the Task runs as a non-administrative user unique to the Task.
	UserIdentity *UserIdentity
}

type CreateTaskOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type CreateTaskResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DataDisk struct {
	// REQUIRED; The initial disk size in gigabytes.
	DiskSizeGB *int32

	// REQUIRED; The logical unit number. The logicalUnitNumber is used to uniquely identify each data disk. If attaching multiple
	// disks, each should have a distinct logicalUnitNumber. The value must be between 0 and 63, inclusive.
	LogicalUnitNumber *int32

	// The type of caching to be enabled for the data disks. The default value for caching is readwrite. For information about
	// the caching options see: https://blogs.msdn.microsoft.com/windowsazurestorage/2012/06/27/exploring-windows-azure-drives-disks-and-images/.
	Caching *CachingType

	// The storage Account type to be used for the data disk. If omitted, the default is "standard_lrs".
	StorageAccountType *StorageAccountType
}

type DeallocateNodeContent struct {
	// When to deallocate the Compute Node and what to do with currently running Tasks. The default value is requeue.
	NodeDeallocateOption *NodeDeallocateOption
}

type DeallocateNodeOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// The options to use for deallocating the Compute Node.
	Parameters *DeallocateNodeContent

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DeallocateNodeResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DeleteCertificateError struct {
	// An identifier for the Certificate deletion error. Codes are invariant and are intended to be consumed programmatically.
	Code *string

	// A message describing the Certificate deletion error, intended to be suitable for display in a user interface.
	Message *string

	// A list of additional error details related to the Certificate deletion error. This list includes details such as the active
	// Pools and Compute Nodes referencing this Certificate. However, if a large number of resources reference the Certificate,
	// the list contains only about the first hundred.
	Values []NameValuePair
}

type DeleteCertificateOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DeleteCertificateResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DeleteJobOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// If true, the server will delete the Job even if the corresponding nodes have not fully processed the deletion. The default
	// value is false.
	Force *bool

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service exactly matches the value specified by the client.
	IfMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// been modified since the specified time.
	IfModifiedSince *time.Time

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service does not match the value specified by the client.
	IfNoneMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// not been modified since the specified time.
	IfUnmodifiedSince *time.Time

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DeleteJobResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DeleteJobScheduleOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// If true, the server will delete the JobSchedule even if the corresponding nodes have not fully processed the deletion.
	// The default value is false.
	Force *bool

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service exactly matches the value specified by the client.
	IfMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// been modified since the specified time.
	IfModifiedSince *time.Time

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service does not match the value specified by the client.
	IfNoneMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// not been modified since the specified time.
	IfUnmodifiedSince *time.Time

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DeleteJobScheduleResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DeleteNodeFileOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether to delete children of a directory. If the filePath parameter represents
	// a directory instead of a file, you can set recursive to true to delete the
	// directory and all of the files and subdirectories in it. If recursive is false
	// then the directory must be empty or deletion will fail.
	Recursive *bool

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DeleteNodeFileResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DeleteNodeUserOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DeleteNodeUserResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DeletePoolOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service exactly matches the value specified by the client.
	IfMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// been modified since the specified time.
	IfModifiedSince *time.Time

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service does not match the value specified by the client.
	IfNoneMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// not been modified since the specified time.
	IfUnmodifiedSince *time.Time

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DeletePoolResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DeleteTaskFileOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether to delete children of a directory. If the filePath parameter represents
	// a directory instead of a file, you can set recursive to true to delete the
	// directory and all of the files and subdirectories in it. If recursive is false
	// then the directory must be empty or deletion will fail.
	Recursive *bool

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DeleteTaskFileResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DeleteTaskOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service exactly matches the value specified by the client.
	IfMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// been modified since the specified time.
	IfModifiedSince *time.Time

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service does not match the value specified by the client.
	IfNoneMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// not been modified since the specified time.
	IfUnmodifiedSince *time.Time

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DeleteTaskResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DependencyAction string

type DiffDiskPlacement string

type DiffDiskSettings struct {
	// Specifies the ephemeral disk placement for operating system disk for all VMs in the pool. This property can be used by
	// user in the request to choose the location e.g., cache disk space for Ephemeral OS disk provisioning. For more information
	// on Ephemeral OS disk size requirements, please refer to Ephemeral OS disk size requirements for Windows VMs at https://learn.microsoft.com/azure/virtual-machines/windows/ephemeral-os-disks#size-requirements
	// and Linux VMs at https://learn.microsoft.com/azure/virtual-machines/linux/ephemeral-os-disks#size-requirements.
	Placement *DiffDiskPlacement
}

type DisableJobContent struct {
	// REQUIRED; What to do with active Tasks associated with the Job.
	DisableTasks *DisableJobOption
}

type DisableJobOption string

type DisableJobOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service exactly matches the value specified by the client.
	IfMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// been modified since the specified time.
	IfModifiedSince *time.Time

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service does not match the value specified by the client.
	IfNoneMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// not been modified since the specified time.
	IfUnmodifiedSince *time.Time

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DisableJobResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DisableJobScheduleOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service exactly matches the value specified by the client.
	IfMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// been modified since the specified time.
	IfModifiedSince *time.Time

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service does not match the value specified by the client.
	IfNoneMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// not been modified since the specified time.
	IfUnmodifiedSince *time.Time

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DisableJobScheduleResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DisableNodeSchedulingContent struct {
	// What to do with currently running Tasks when disabling Task scheduling on the Compute Node. The default value is requeue.
	NodeDisableSchedulingOption *NodeDisableSchedulingOption
}

type DisableNodeSchedulingOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// The options to use for disabling scheduling on the Compute Node.
	Parameters *DisableNodeSchedulingContent

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DisableNodeSchedulingResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DisablePoolAutoScaleOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type DisablePoolAutoScaleResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type DiskEncryptionConfiguration struct {
	// The list of disk targets Batch Service will encrypt on the compute node. The list of disk targets Batch Service will encrypt
	// on the compute node.
	Targets []DiskEncryptionTarget
}

type DiskEncryptionTarget string

type DynamicVNetAssignmentScope string

type ElevationLevel string

type EnableJobOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service exactly matches the value specified by the client.
	IfMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// been modified since the specified time.
	IfModifiedSince *time.Time

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service does not match the value specified by the client.
	IfNoneMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// not been modified since the specified time.
	IfUnmodifiedSince *time.Time

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type EnableJobResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type EnableJobScheduleOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service exactly matches the value specified by the client.
	IfMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// been modified since the specified time.
	IfModifiedSince *time.Time

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service does not match the value specified by the client.
	IfNoneMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// not been modified since the specified time.
	IfUnmodifiedSince *time.Time

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type EnableJobScheduleResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type EnableNodeSchedulingOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}

type EnableNodeSchedulingResponse struct {
	// The client-request-id provided by the client during the request. This will be returned only if the return-client-request-id
	// parameter was set to true.
	ClientRequestID *string

	// The OData ID of the resource to which the request applied.
	DataServiceID *string

	// The ETag HTTP response header. This is an opaque string. You can use it to detect whether the resource has changed between
	// requests. In particular, you can pass the ETag to one of the If-Modified-Since, If-Unmodified-Since, If-Match or If-None-Match
	// headers.
	ETag *azcore.ETag

	// The time at which the resource was last modified.
	LastModified *time.Time

	// A unique identifier for the request that was made to the Batch service. If a request is consistently failing and you have
	// verified that the request is properly formulated, you may use this value to report the error to Microsoft. In your report,
	// include the value of this request ID, the approximate time that the request was made, the Batch Account against which the
	// request was made, and the region that Account resides in.
	RequestID *string
}

type EnablePoolAutoScaleContent struct {
	// The time interval at which to automatically adjust the Pool size according to the autoscale formula. The default value
	// is 15 minutes. The minimum and maximum value are 5 minutes and 168 hours respectively. If you specify a value less than
	// 5 minutes or greater than 168 hours, the Batch service rejects the request with an invalid property value error; if you
	// are calling the REST API directly, the HTTP status code is 400 (Bad Request). If you specify a new interval, then the existing
	// autoscale evaluation schedule will be stopped and a new autoscale evaluation schedule will be started, with its starting
	// time being the time when this request was issued.
	AutoScaleEvaluationInterval *string

	// The formula for the desired number of Compute Nodes in the Pool. The default value is 15 minutes. The minimum and maximum
	// value are 5 minutes and 168 hours respectively. If you specify a value less than 5 minutes or greater than 168 hours, the
	// Batch service rejects the request with an invalid property value error; if you are calling the REST API directly, the HTTP
	// status code is 400 (Bad Request). If you specify a new interval, then the existing autoscale evaluation schedule will be
	// stopped and a new autoscale evaluation schedule will be started, with its starting time being the time when this request
	// was issued.
	AutoScaleFormula *string
}

type EnablePoolAutoScaleOptions struct {
	// The caller-generated request identity, in the form of a GUID with no decoration
	// such as curly braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.
	ClientRequestID *string

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service exactly matches the value specified by the client.
	IfMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// been modified since the specified time.
	IfModifiedSince *time.Time

	// An ETag value associated with the version of the resource known to the client.
	// The operation will be performed only if the resource's current ETag on the
	// service does not match the value specified by the client.
	IfNoneMatch *azcore.ETag

	// A timestamp indicating the last modified time of the resource known to the
	// client. The operation will be performed only if the resource on the service has
	// not been modified since the specified time.
	IfUnmodifiedSince *time.Time

	// The time the request was issued. Client libraries typically set this to the
	// current system clock time; set it explicitly if you are calling the REST API
	// directly.
	OCPDate *time.Time

	// Whether the server should return the client-request-id in the response.
	ReturnClientRequestID *bool

	// The maximum time that the server can spend processing the request, in seconds. The default is 30 seconds. If the value
	// is larger than 30, the default will be used instead.".
	Timeout *int32
}