Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the MIT License. See License.txt in the project root for
license information.
/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for
 * license information.
 */
package com.microsoft.azure.management.containerregistry;

import com.microsoft.azure.management.apigeneration.Beta;
import com.microsoft.azure.management.apigeneration.Fluent;
import com.microsoft.azure.management.containerregistry.implementation.RunInner;
import com.microsoft.azure.management.resources.fluentcore.model.Executable;
import com.microsoft.azure.management.resources.fluentcore.model.HasInner;
import com.microsoft.azure.management.resources.fluentcore.model.Refreshable;
import org.joda.time.DateTime;

import java.util.Map;

An immutable client-side representation of an Azure RegistryDockerTaskRunRequest registry task run request.
/**
 * An immutable client-side representation of an Azure RegistryDockerTaskRunRequest registry task run request.
 */
@Fluent()
@Beta(Beta.SinceVersion.V1_17_0)
public interface RegistryTaskRun extends
        HasInner<RunInner>,
        Refreshable<RegistryTaskRun> {
    
Returns:
the name of the resource group for this task run request/**
     * @return the name of the resource group for this task run request
     */
    String resourceGroupName();

    
Returns:
the registry name of this task run request/**
     * @return the registry name of this task run request
     */
    String registryName();

    
Returns:
the name of the task in the case of a TaskRunRequest (or null if task is still queued), null in other cases/**
     * @return the name of the task in the case of a TaskRunRequest (or null if task is still queued), null in other cases
     */
    String taskName();

    
Returns:
the status of the run request/**
     * @return the status of the run request
     */
    RunStatus status();

    
Returns:
the run type of the run request/**
     * @return the run type of the run request
     */
    RunType runType();

    
Returns:
the last time the run request was updated/**
     * @return the last time the run request was updated
     */
    DateTime lastUpdatedTime();

    
Returns:
the time when the run request was created/**
     * @return the time when the run request was created
     */
    DateTime createTime();

    
Returns:
whether archiving is enabled for the run request/**
     * @return whether archiving is enabled for the run request
     */
    boolean isArchiveEnabled();

    
Returns:
the platform properties of the run request/**
     * @return the platform properties of the run request
     */
    PlatformProperties platform();

    
Returns:
the numbers of cpu/**
     * @return the numbers of cpu
     */
    int cpu();

    
Returns:
the provisioning state of the run request/**
     * @return the provisioning state of the run request
     */
    ProvisioningState provisioningState();

    
Returns:
the id of the run/**
     * @return the id of the run
     */
    String runId();

    
Container interface for all the definitions related to a RegistryTaskRun.
/**
     * Container interface for all the definitions related to a RegistryTaskRun.
     */
    interface Definition extends
        DefinitionStages.BlankFromRegistry,
        DefinitionStages.BlankFromRuns,
        DefinitionStages.Platform,
        DefinitionStages.PlatformAltTaskRunRequest,
        DefinitionStages.RegistryTaskRunRequest,
        DefinitionStages.RunRequestType,
        DefinitionStages.RunRequestExecutableWithSourceLocation,
        DefinitionStages.RunRequestExecutable {
    }

    
Grouping of registry task run definition stages.
/**
     * Grouping of registry task run definition stages.
     */
    interface DefinitionStages {
        
The first stage of a a RegistryTaskRun definition if originating from a call on a registry.
/**
         * The first stage of a a RegistryTaskRun definition if originating from a call on a registry.
         */
        interface BlankFromRegistry extends PlatformAltTaskRunRequest  {
        }

        
The first stage of a RegistryTaskRun definition if definition is originating from a call on an existing RegistryTaskRun.
/**
         * The first stage of a RegistryTaskRun definition if definition is originating from a call on an existing RegistryTaskRun.
         */
        interface BlankFromRuns  {
            
The function that specifies the registry this task run is called on.
Params:
resourceGroupName – the name of the resource group of the registry.
registryName – the name of the registry.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the registry this task run is called on.
             *
             * @param resourceGroupName the name of the resource group of the registry.
             * @param registryName the name of the registry.
             * @return the next stage of the container registry task run definition.
             */
            PlatformAltTaskRunRequest withExistingRegistry(String resourceGroupName, String registryName);
        }

        
The stage of the container registry task run definition that allows to specify the task run is going to be run
with a TaskRunRequest.
/**
         * The stage of the container registry task run definition that allows to specify the task run is going to be run
         * with a TaskRunRequest.
         */
        interface PlatformAltTaskRunRequest extends Platform {
            
The function that specifies the name of the existing task to run.
Params:
taskName – the name of the created task to pass into the task run request.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the name of the existing task to run.
             *
             * @param taskName the name of the created task to pass into the task run request.
             * @return the next stage of the container registry task run definition.
             */
            RegistryTaskRunRequest withTaskRunRequest(String taskName);
        }

        
The stage of the container registry task definition for TaskRunRequests that allows the user to specify overriding values
and whether archiving is enabled or not.
/**
         * The stage of the container registry task definition for TaskRunRequests that allows the user to specify overriding values
         * and whether archiving is enabled or not.
         */
        interface RegistryTaskRunRequest extends RunRequestExecutable  {
            
The function that specifies whether there are any values that will be overridden and what they will be overridden by.
Params:
overridingValues – a map that has the name of the value to be overridden as the key and the value is an OverridingValue.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies whether there are any values that will be overridden and what they will be overridden by.
             *
             * @param overridingValues a map that has the name of the value to be overridden as the key and the value is an OverridingValue.
             * @return the next stage of the container registry task run definition.
             */
            RegistryTaskRunRequest withOverridingValues(Map<String, OverridingValue> overridingValues);

            
The function that specifies whether a single value will be overridden and what it will be overridden by.
Params:
name – the name of the value to be overridden.
overridingValue – the OverridingValue specifying what the value will be overridden with.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies whether a single value will be overridden and what it will be overridden by.
             *
             * @param name the name of the value to be overridden.
             * @param overridingValue the OverridingValue specifying what the value will be overridden with.
             * @return the next stage of the container registry task run definition.
             */
            RegistryTaskRunRequest withOverridingValue(String name, OverridingValue overridingValue);

            
The function that specifies archiving will or will not be enabled.
Params:
enabled – whether archive will be enabled.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies archiving will or will not be enabled.
             *
             * @param enabled whether archive will be enabled.
             * @return the next stage of the container registry task run definition.
             */
            RegistryTaskRunRequest withArchiveEnabled(boolean enabled);

        }

        
The stage of the container registry task definition that specifies the platform for the container registry task run.
/**
         * The stage of the container registry task definition that specifies the platform for the container registry task run.
         */
        interface Platform {
            
The function that specifies the platform will have a Linux OS.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the platform will have a Linux OS.
             *
             * @return the next stage of the container registry task run definition.
             */
            RunRequestType withLinux();

            
The function that specifies the platform will have a Windows OS.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the platform will have a Windows OS.
             *
             * @return the next stage of the container registry task run definition.
             */
            RunRequestType withWindows();

            
The function that specifies the platform will have a Linux OS with Architecture architecture.
Params:
architecture – the architecture the platform will have.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the platform will have a Linux OS with Architecture architecture.
             *
             * @param architecture the architecture the platform will have.
             * @return the next stage of the container registry task run definition.
             */
            RunRequestType withLinux(Architecture architecture);

            
The function that specifies the platform will have a Windows OS with Architecture architecture.
Params:
architecture – the architecture the platform will have.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the platform will have a Windows OS with Architecture architecture.
             *
             * @param architecture the architecture the platform will have.
             * @return the next stage of the container registry task run definition.
             */
            RunRequestType withWindows(Architecture architecture);

            
The function that specifies the platform will have a Linux OS with Architecture architecture and Variant variant.
Params:
architecture – the architecture the platform will have.
variant – the variant the platform will have.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the platform will have a Linux OS with Architecture architecture and Variant variant.
             *
             * @param architecture the architecture the platform will have.
             * @param variant the variant the platform will have.
             * @return the next stage of the container registry task run definition.
             */
            RunRequestType withLinux(Architecture architecture, Variant variant);

            
The function that specifies the platform will have a Windows OS with Architecture architecture and Variant variant.
Params:
architecture – the architecture the platform will have.
variant – the variant the platform will have.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the platform will have a Windows OS with Architecture architecture and Variant variant.
             *
             * @param architecture the architecture the platform will have.
             * @param variant the variant the platform will have.
             * @return the next stage of the container registry task run definition.
             */
            RunRequestType withWindows(Architecture architecture, Variant variant);

            
The function that specifies the platform properties of the registry task run.
Params:
platformProperties – the properties of the platform.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the platform properties of the registry task run.
             *
             * @param platformProperties the properties of the platform.
             * @return the next stage of the container registry task run definition.
             */
            RunRequestType withPlatform(PlatformProperties platformProperties);
        }

        
The stage of the definition that specifies the task run request type.
/**
         * The stage of the definition that specifies the task run request type.
         */
        interface RunRequestType {
            
The function that specifies the task run request type will be a file task.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the task run request type will be a file task.
             *
             * @return the next stage of the container registry task run definition.
             */
            RegistryFileTaskRunRequest.DefinitionStages.Blank withFileTaskRunRequest();

            
The function that specifies the task run request type will be an encoded task.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the task run request type will be an encoded task.
             *
             * @return the next stage of the container registry task run definition.
             */
            RegistryEncodedTaskRunRequest.DefinitionStages.Blank withEncodedTaskRunRequest();

            
The function that specifies the task run request type will be a Docker task.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the task run request type will be a Docker task.
             *
             * @return the next stage of the container registry task run definition.
             */
            RegistryDockerTaskRunRequest.DefinitionStages.Blank withDockerTaskRunRequest();
        }

        
The stage of the container registry task run that specifies the AgentConfiguration for the container registry task run.
/**
         * The stage of the container registry task run that specifies the AgentConfiguration for the container registry task run.
         */
        interface AgentConfiguration {
            
The function that specifies the count of the CPU.
Params:
count – the CPU count.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the count of the CPU.
             *
             * @param count the CPU count.
             * @return the next stage of the container registry task run definition.
             */
            RunRequestExecutable withCpuCount(int count);
        }

        
The stage of the container registry task run definition that specifies the enabling and disabling of archiving.
/**
         * The stage of the container registry task run definition that specifies the enabling and disabling of archiving.
         */
        interface Archive {
            
The function that specifies archiving is enabled or disabled.
Params:
enabled – whether archiving is enabled or not.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies archiving is enabled or disabled.
             *
             * @param enabled whether archiving is enabled or not.
             * @return the next stage of the container registry task run definition.
             */
            RunRequestExecutable withArchiveEnabled(boolean enabled);
        }

        
The stage of the container registry task run definition which contains all the minimum required inputs for the resource to be executed
if the task run request type is either file, encoded, or Docker, but also allows for any other optional settings to be specified.
/**
         * The stage of the container registry task run definition which contains all the minimum required inputs for the resource to be executed
         * if the task run request type is either file, encoded, or Docker, but also allows for any other optional settings to be specified.
         */
        interface RunRequestExecutableWithSourceLocation extends
                AgentConfiguration,
                RunRequestExecutable {
            
The function that specifies the location of the source control.
Params:
location – the location of the source control.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the location of the source control.
             *
             * @param location the location of the source control.
             * @return the next stage of the container registry task run definition.
             */
            RunRequestExecutableWithSourceLocation withSourceLocation(String location);

            
The function that specifies the timeout.
Params:
timeout – the time the timeout lasts.
Returns:
the next stage of the container registry task run definition./**
             * The function that specifies the timeout.
             *
             * @param timeout the time the timeout lasts.
             * @return the next stage of the container registry task run definition.
             */
            RunRequestExecutableWithSourceLocation withTimeout(int timeout);
        }

        
The stage of the definition in the case of using a TaskRunRequest which contains
all the minimum required inputs for the resource to be executed, but also allows for any other optional settings
to be specified.
/**
         * The stage of the definition in the case of using a TaskRunRequest which contains
         * all the minimum required inputs for the resource to be executed, but also allows for any other optional settings
         * to be specified.
         */
        interface RunRequestExecutable extends
                Archive,
                Executable<RegistryTaskRun> {
        }
    }
}