/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetPeerRequest, GetPeerResponse> ForPeer(GetPeerRequest request, WaiterConfiguration config, params Peer.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetPeerRequest, GetPeerResponse>(
request,
request => client.GetPeer(request),
response => targetStates.Contains(response.Peer.LifecycleState.Value)
);
return(new Waiter <GetPeerRequest, GetPeerResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetStorageWorkRequestRequest, GetStorageWorkRequestResponse> ForStorageWorkRequest(GetStorageWorkRequestRequest request, WaiterConfiguration config, params WorkRequestStatus[] targetStates)
{
var agent = new WaiterAgent <GetStorageWorkRequestRequest, GetStorageWorkRequestResponse>(
request,
request => client.GetStorageWorkRequest(request),
response => targetStates.Contains(response.StorageWorkRequest.Status.Value)
);
return(new Waiter <GetStorageWorkRequestRequest, GetStorageWorkRequestResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetJobExecutionRequest, GetJobExecutionResponse> ForJobExecution(GetJobExecutionRequest request, WaiterConfiguration config, params JobExecutionState[] targetStates)
{
var agent = new WaiterAgent <GetJobExecutionRequest, GetJobExecutionResponse>(
request,
request => client.GetJobExecution(request),
response => targetStates.Contains(response.JobExecution.LifecycleState.Value)
);
return(new Waiter <GetJobExecutionRequest, GetJobExecutionResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetDomainGovernanceRequest, GetDomainGovernanceResponse> ForDomainGovernance(GetDomainGovernanceRequest request, WaiterConfiguration config, params DomainGovernance.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetDomainGovernanceRequest, GetDomainGovernanceResponse>(
request,
request => client.GetDomainGovernance(request),
response => targetStates.Contains(response.DomainGovernance.LifecycleState.Value)
);
return(new Waiter <GetDomainGovernanceRequest, GetDomainGovernanceResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetTransferApplianceEntitlementRequest, GetTransferApplianceEntitlementResponse> ForTransferApplianceEntitlement(GetTransferApplianceEntitlementRequest request, WaiterConfiguration config, params TransferApplianceEntitlement.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetTransferApplianceEntitlementRequest, GetTransferApplianceEntitlementResponse>(
request,
request => client.GetTransferApplianceEntitlement(request),
response => targetStates.Contains(response.TransferApplianceEntitlement.LifecycleState.Value),
targetStates.Contains(TransferApplianceEntitlement.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetTransferApplianceEntitlementRequest, GetTransferApplianceEntitlementResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetConnectHarnessRequest, GetConnectHarnessResponse> ForConnectHarness(GetConnectHarnessRequest request, WaiterConfiguration config, params ConnectHarness.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetConnectHarnessRequest, GetConnectHarnessResponse>(
request,
request => client.GetConnectHarness(request),
response => targetStates.Contains(response.ConnectHarness.LifecycleState.Value),
targetStates.Contains(ConnectHarness.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetConnectHarnessRequest, GetConnectHarnessResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetAnalyticsClusterRequest, GetAnalyticsClusterResponse> ForAnalyticsCluster(GetAnalyticsClusterRequest request, WaiterConfiguration config, params AnalyticsCluster.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetAnalyticsClusterRequest, GetAnalyticsClusterResponse>(
request,
request => client.GetAnalyticsCluster(request),
response => targetStates.Contains(response.AnalyticsCluster.LifecycleState.Value),
targetStates.Contains(AnalyticsCluster.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetAnalyticsClusterRequest, GetAnalyticsClusterResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetFileSystemRequest, GetFileSystemResponse> ForFileSystem(GetFileSystemRequest request, WaiterConfiguration config, params FileSystem.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetFileSystemRequest, GetFileSystemResponse>(
request,
request => client.GetFileSystem(request),
response => targetStates.Contains(response.FileSystem.LifecycleState.Value),
targetStates.Contains(FileSystem.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetFileSystemRequest, GetFileSystemResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetEnterpriseManagerBridgeRequest, GetEnterpriseManagerBridgeResponse> ForEnterpriseManagerBridge(GetEnterpriseManagerBridgeRequest request, WaiterConfiguration config, params LifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetEnterpriseManagerBridgeRequest, GetEnterpriseManagerBridgeResponse>(
request,
request => client.GetEnterpriseManagerBridge(request),
response => targetStates.Contains(response.EnterpriseManagerBridge.LifecycleState.Value),
targetStates.Contains(LifecycleState.Deleted)
);
return(new Waiter <GetEnterpriseManagerBridgeRequest, GetEnterpriseManagerBridgeResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetModelRequest, GetModelResponse> ForModel(GetModelRequest request, WaiterConfiguration config, params ModelLifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetModelRequest, GetModelResponse>(
request,
request => client.GetModel(request),
response => targetStates.Contains(response.Model.LifecycleState.Value),
targetStates.Contains(ModelLifecycleState.Deleted)
);
return(new Waiter <GetModelRequest, GetModelResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetInstanceConsoleConnectionRequest, GetInstanceConsoleConnectionResponse> ForInstanceConsoleConnection(GetInstanceConsoleConnectionRequest request, WaiterConfiguration config, params InstanceConsoleConnection.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetInstanceConsoleConnectionRequest, GetInstanceConsoleConnectionResponse>(
request,
request => client.GetInstanceConsoleConnection(request),
response => targetStates.Contains(response.InstanceConsoleConnection.LifecycleState.Value),
targetStates.Contains(InstanceConsoleConnection.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetInstanceConsoleConnectionRequest, GetInstanceConsoleConnectionResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetManagedDatabaseGroupRequest, GetManagedDatabaseGroupResponse> ForManagedDatabaseGroup(GetManagedDatabaseGroupRequest request, WaiterConfiguration config, params LifecycleStates[] targetStates)
{
var agent = new WaiterAgent <GetManagedDatabaseGroupRequest, GetManagedDatabaseGroupResponse>(
request,
request => client.GetManagedDatabaseGroup(request),
response => targetStates.Contains(response.ManagedDatabaseGroup.LifecycleState.Value),
targetStates.Contains(LifecycleStates.Deleted)
);
return(new Waiter <GetManagedDatabaseGroupRequest, GetManagedDatabaseGroupResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetClusterNetworkRequest, GetClusterNetworkResponse> ForClusterNetwork(GetClusterNetworkRequest request, WaiterConfiguration config, params ClusterNetwork.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetClusterNetworkRequest, GetClusterNetworkResponse>(
request,
request => client.GetClusterNetwork(request),
response => targetStates.Contains(response.ClusterNetwork.LifecycleState.Value),
targetStates.Contains(ClusterNetwork.LifecycleStateEnum.Terminated)
);
return(new Waiter <GetClusterNetworkRequest, GetClusterNetworkResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetBlockchainPlatformRequest, GetBlockchainPlatformResponse> ForBlockchainPlatform(GetBlockchainPlatformRequest request, WaiterConfiguration config, params BlockchainPlatform.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetBlockchainPlatformRequest, GetBlockchainPlatformResponse>(
request,
request => client.GetBlockchainPlatform(request),
response => targetStates.Contains(response.BlockchainPlatform.LifecycleState.Value),
targetStates.Contains(BlockchainPlatform.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetBlockchainPlatformRequest, GetBlockchainPlatformResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetHostVulnerabilityRequest, GetHostVulnerabilityResponse> ForHostVulnerability(GetHostVulnerabilityRequest request, WaiterConfiguration config, params LifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetHostVulnerabilityRequest, GetHostVulnerabilityResponse>(
request,
request => client.GetHostVulnerability(request),
response => targetStates.Contains(response.HostVulnerability.LifecycleState.Value),
targetStates.Contains(LifecycleState.Deleted)
);
return(new Waiter <GetHostVulnerabilityRequest, GetHostVulnerabilityResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetNotebookSessionRequest, GetNotebookSessionResponse> ForNotebookSession(GetNotebookSessionRequest request, WaiterConfiguration config, params NotebookSessionLifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetNotebookSessionRequest, GetNotebookSessionResponse>(
request,
request => client.GetNotebookSession(request),
response => targetStates.Contains(response.NotebookSession.LifecycleState.Value),
targetStates.Contains(NotebookSessionLifecycleState.Deleted)
);
return(new Waiter <GetNotebookSessionRequest, GetNotebookSessionResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetProjectRequest, GetProjectResponse> ForProject(GetProjectRequest request, WaiterConfiguration config, params ProjectLifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetProjectRequest, GetProjectResponse>(
request,
request => client.GetProject(request),
response => targetStates.Contains(response.Project.LifecycleState.Value),
targetStates.Contains(ProjectLifecycleState.Deleted)
);
return(new Waiter <GetProjectRequest, GetProjectResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetServiceConnectorRequest, GetServiceConnectorResponse> ForServiceConnector(GetServiceConnectorRequest request, WaiterConfiguration config, params LifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetServiceConnectorRequest, GetServiceConnectorResponse>(
request,
request => client.GetServiceConnector(request),
response => targetStates.Contains(response.ServiceConnector.LifecycleState.Value),
targetStates.Contains(LifecycleState.Deleted)
);
return(new Waiter <GetServiceConnectorRequest, GetServiceConnectorResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetDatabaseInsightRequest, GetDatabaseInsightResponse> ForDatabaseInsight(GetDatabaseInsightRequest request, WaiterConfiguration config, params LifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetDatabaseInsightRequest, GetDatabaseInsightResponse>(
request,
request => client.GetDatabaseInsight(request),
response => targetStates.Contains(response.DatabaseInsight.LifecycleState.Value),
targetStates.Contains(LifecycleState.Deleted)
);
return(new Waiter <GetDatabaseInsightRequest, GetDatabaseInsightResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetIdpGroupMappingRequest, GetIdpGroupMappingResponse> ForIdpGroupMapping(GetIdpGroupMappingRequest request, WaiterConfiguration config, params IdpGroupMapping.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetIdpGroupMappingRequest, GetIdpGroupMappingResponse>(
request,
request => client.GetIdpGroupMapping(request),
response => targetStates.Contains(response.IdpGroupMapping.LifecycleState.Value),
targetStates.Contains(IdpGroupMapping.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetIdpGroupMappingRequest, GetIdpGroupMappingResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetJobRequest, GetJobResponse> ForJob(GetJobRequest request, WaiterConfiguration config, params JobLifecycleStates[] targetStates)
{
var agent = new WaiterAgent <GetJobRequest, GetJobResponse>(
request,
request => client.GetJob(request),
response => targetStates.Contains(response.Job.LifecycleState.Value),
targetStates.Contains(JobLifecycleStates.Terminated)
);
return(new Waiter <GetJobRequest, GetJobResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetUserGroupMembershipRequest, GetUserGroupMembershipResponse> ForUserGroupMembership(GetUserGroupMembershipRequest request, WaiterConfiguration config, params UserGroupMembership.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetUserGroupMembershipRequest, GetUserGroupMembershipResponse>(
request,
request => client.GetUserGroupMembership(request),
response => targetStates.Contains(response.UserGroupMembership.LifecycleState.Value),
targetStates.Contains(UserGroupMembership.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetUserGroupMembershipRequest, GetUserGroupMembershipResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetBootVolumeBackupRequest, GetBootVolumeBackupResponse> ForBootVolumeBackup(GetBootVolumeBackupRequest request, WaiterConfiguration config, params BootVolumeBackup.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetBootVolumeBackupRequest, GetBootVolumeBackupResponse>(
request,
request => client.GetBootVolumeBackup(request),
response => targetStates.Contains(response.BootVolumeBackup.LifecycleState.Value),
targetStates.Contains(BootVolumeBackup.LifecycleStateEnum.Terminated)
);
return(new Waiter <GetBootVolumeBackupRequest, GetBootVolumeBackupResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetLogAnalyticsEntityRequest, GetLogAnalyticsEntityResponse> ForLogAnalyticsEntity(GetLogAnalyticsEntityRequest request, WaiterConfiguration config, params EntityLifecycleStates[] targetStates)
{
var agent = new WaiterAgent <GetLogAnalyticsEntityRequest, GetLogAnalyticsEntityResponse>(
request,
request => client.GetLogAnalyticsEntity(request),
response => targetStates.Contains(response.LogAnalyticsEntity.LifecycleState.Value),
targetStates.Contains(EntityLifecycleStates.Deleted)
);
return(new Waiter <GetLogAnalyticsEntityRequest, GetLogAnalyticsEntityResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetCertificateRequest, GetCertificateResponse> ForCertificate(GetCertificateRequest request, WaiterConfiguration config, params LifecycleStates[] targetStates)
{
var agent = new WaiterAgent <GetCertificateRequest, GetCertificateResponse>(
request,
request => client.GetCertificate(request),
response => targetStates.Contains(response.Certificate.LifecycleState.Value),
targetStates.Contains(LifecycleStates.Deleted)
);
return(new Waiter <GetCertificateRequest, GetCertificateResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetOperatorControlRequest, GetOperatorControlResponse> ForOperatorControl(GetOperatorControlRequest request, WaiterConfiguration config, params OperatorControlLifecycleStates[] targetStates)
{
var agent = new WaiterAgent <GetOperatorControlRequest, GetOperatorControlResponse>(
request,
request => client.GetOperatorControl(request),
response => targetStates.Contains(response.OperatorControl.LifecycleState.Value),
targetStates.Contains(OperatorControlLifecycleStates.Deleted)
);
return(new Waiter <GetOperatorControlRequest, GetOperatorControlResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetDeploymentRequest, GetDeploymentResponse> ForDeployment(GetDeploymentRequest request, WaiterConfiguration config, params Deployment.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetDeploymentRequest, GetDeploymentResponse>(
request,
request => client.GetDeployment(request),
response => targetStates.Contains(response.Deployment.LifecycleState.Value),
targetStates.Contains(Deployment.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetDeploymentRequest, GetDeploymentResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetLinkRequest, GetLinkResponse> ForLink(GetLinkRequest request, WaiterConfiguration config, params LifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetLinkRequest, GetLinkResponse>(
request,
request => client.GetLink(request),
response => targetStates.Contains(response.Link.LifecycleState.Value),
targetStates.Contains(LifecycleState.Terminated)
);
return(new Waiter <GetLinkRequest, GetLinkResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetWorkspaceRequest, GetWorkspaceResponse> ForWorkspace(GetWorkspaceRequest request, WaiterConfiguration config, params Workspace.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetWorkspaceRequest, GetWorkspaceResponse>(
request,
request => client.GetWorkspace(request),
response => targetStates.Contains(response.Workspace.LifecycleState.Value),
targetStates.Contains(Workspace.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetWorkspaceRequest, GetWorkspaceResponse>(config, agent));
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetSteeringPolicyRequest, GetSteeringPolicyResponse> ForSteeringPolicy(GetSteeringPolicyRequest request, WaiterConfiguration config, params SteeringPolicy.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetSteeringPolicyRequest, GetSteeringPolicyResponse>(
request,
request => client.GetSteeringPolicy(request),
response => targetStates.Contains(response.SteeringPolicy.LifecycleState.Value),
targetStates.Contains(SteeringPolicy.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetSteeringPolicyRequest, GetSteeringPolicyResponse>(config, agent));
}
