GDC Hardware Management v1alpha API - Class GDCHardwareManagementClient (1.0.0-alpha01)

public abstract class GDCHardwareManagementClient

Namespace

Assembly

Google.Cloud.GdcHardwareManagement.V1Alpha.dll

Remarks

Properties

CreateCommentOperationsClient

public virtual OperationsClient CreateCommentOperationsClient { get; }

CreateHardwareGroupOperationsClient

public virtual OperationsClient CreateHardwareGroupOperationsClient { get; }

CreateHardwareOperationsClient

public virtual OperationsClient CreateHardwareOperationsClient { get; }

CreateOrderOperationsClient

public virtual OperationsClient CreateOrderOperationsClient { get; }

CreateSiteOperationsClient

public virtual OperationsClient CreateSiteOperationsClient { get; }

CreateZoneOperationsClient

public virtual OperationsClient CreateZoneOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteHardwareGroupOperationsClient

public virtual OperationsClient DeleteHardwareGroupOperationsClient { get; }

DeleteHardwareOperationsClient

public virtual OperationsClient DeleteHardwareOperationsClient { get; }

DeleteOrderOperationsClient

public virtual OperationsClient DeleteOrderOperationsClient { get; }

DeleteZoneOperationsClient

public virtual OperationsClient DeleteZoneOperationsClient { get; }

GrpcClient

public virtual GDCHardwareManagement.GDCHardwareManagementClient GrpcClient { get; }

LocationsClient

public virtual LocationsClient LocationsClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

SignalZoneStateOperationsClient

public virtual OperationsClient SignalZoneStateOperationsClient { get; }

SubmitOrderOperationsClient

public virtual OperationsClient SubmitOrderOperationsClient { get; }

UpdateHardwareGroupOperationsClient

public virtual OperationsClient UpdateHardwareGroupOperationsClient { get; }

UpdateHardwareOperationsClient

public virtual OperationsClient UpdateHardwareOperationsClient { get; }

UpdateOrderOperationsClient

public virtual OperationsClient UpdateOrderOperationsClient { get; }

UpdateSiteOperationsClient

public virtual OperationsClient UpdateSiteOperationsClient { get; }

UpdateZoneOperationsClient

public virtual OperationsClient UpdateZoneOperationsClient { get; }

Methods

Create()

public static GDCHardwareManagementClient Create()

CreateAsync(CancellationToken)

public static Task<GDCHardwareManagementClient> CreateAsync(CancellationToken cancellationToken = default)

CreateComment(CreateCommentRequest, CallSettings)

public virtual Operation<Comment, OperationMetadata> CreateComment(CreateCommentRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
CreateCommentRequest request = new CreateCommentRequest
{
    ParentAsOrderName = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]"),
    CommentId = "",
    Comment = new Comment(),
    RequestId = "",
};
// Make the request
Operation<Comment, OperationMetadata> response = gDCHardwareManagementClient.CreateComment(request);

// Poll until the returned long-running operation is complete
Operation<Comment, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Comment result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Comment, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateComment(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Comment retrievedResult = retrievedResponse.Result;
}

CreateComment(OrderName, Comment, string, CallSettings)

public virtual Operation<Comment, OperationMetadata> CreateComment(OrderName parent, Comment comment, string commentId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
OrderName parent = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]");
Comment comment = new Comment();
string commentId = "";
// Make the request
Operation<Comment, OperationMetadata> response = gDCHardwareManagementClient.CreateComment(parent, comment, commentId);

// Poll until the returned long-running operation is complete
Operation<Comment, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Comment result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Comment, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateComment(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Comment retrievedResult = retrievedResponse.Result;
}

CreateComment(string, Comment, string, CallSettings)

public virtual Operation<Comment, OperationMetadata> CreateComment(string parent, Comment comment, string commentId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]";
Comment comment = new Comment();
string commentId = "";
// Make the request
Operation<Comment, OperationMetadata> response = gDCHardwareManagementClient.CreateComment(parent, comment, commentId);

// Poll until the returned long-running operation is complete
Operation<Comment, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Comment result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Comment, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateComment(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Comment retrievedResult = retrievedResponse.Result;
}

CreateCommentAsync(CreateCommentRequest, CallSettings)

public virtual Task<Operation<Comment, OperationMetadata>> CreateCommentAsync(CreateCommentRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateCommentRequest request = new CreateCommentRequest
{
    ParentAsOrderName = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]"),
    CommentId = "",
    Comment = new Comment(),
    RequestId = "",
};
// Make the request
Operation<Comment, OperationMetadata> response = await gDCHardwareManagementClient.CreateCommentAsync(request);

// Poll until the returned long-running operation is complete
Operation<Comment, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Comment result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Comment, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateCommentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Comment retrievedResult = retrievedResponse.Result;
}

CreateCommentAsync(CreateCommentRequest, CancellationToken)

public virtual Task<Operation<Comment, OperationMetadata>> CreateCommentAsync(CreateCommentRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateCommentRequest request = new CreateCommentRequest
{
    ParentAsOrderName = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]"),
    CommentId = "",
    Comment = new Comment(),
    RequestId = "",
};
// Make the request
Operation<Comment, OperationMetadata> response = await gDCHardwareManagementClient.CreateCommentAsync(request);

// Poll until the returned long-running operation is complete
Operation<Comment, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Comment result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Comment, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateCommentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Comment retrievedResult = retrievedResponse.Result;
}

CreateCommentAsync(OrderName, Comment, string, CallSettings)

public virtual Task<Operation<Comment, OperationMetadata>> CreateCommentAsync(OrderName parent, Comment comment, string commentId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
OrderName parent = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]");
Comment comment = new Comment();
string commentId = "";
// Make the request
Operation<Comment, OperationMetadata> response = await gDCHardwareManagementClient.CreateCommentAsync(parent, comment, commentId);

// Poll until the returned long-running operation is complete
Operation<Comment, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Comment result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Comment, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateCommentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Comment retrievedResult = retrievedResponse.Result;
}

CreateCommentAsync(OrderName, Comment, string, CancellationToken)

public virtual Task<Operation<Comment, OperationMetadata>> CreateCommentAsync(OrderName parent, Comment comment, string commentId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
OrderName parent = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]");
Comment comment = new Comment();
string commentId = "";
// Make the request
Operation<Comment, OperationMetadata> response = await gDCHardwareManagementClient.CreateCommentAsync(parent, comment, commentId);

// Poll until the returned long-running operation is complete
Operation<Comment, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Comment result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Comment, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateCommentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Comment retrievedResult = retrievedResponse.Result;
}

CreateCommentAsync(string, Comment, string, CallSettings)

public virtual Task<Operation<Comment, OperationMetadata>> CreateCommentAsync(string parent, Comment comment, string commentId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]";
Comment comment = new Comment();
string commentId = "";
// Make the request
Operation<Comment, OperationMetadata> response = await gDCHardwareManagementClient.CreateCommentAsync(parent, comment, commentId);

// Poll until the returned long-running operation is complete
Operation<Comment, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Comment result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Comment, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateCommentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Comment retrievedResult = retrievedResponse.Result;
}

CreateCommentAsync(string, Comment, string, CancellationToken)

public virtual Task<Operation<Comment, OperationMetadata>> CreateCommentAsync(string parent, Comment comment, string commentId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]";
Comment comment = new Comment();
string commentId = "";
// Make the request
Operation<Comment, OperationMetadata> response = await gDCHardwareManagementClient.CreateCommentAsync(parent, comment, commentId);

// Poll until the returned long-running operation is complete
Operation<Comment, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Comment result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Comment, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateCommentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Comment retrievedResult = retrievedResponse.Result;
}

CreateHardware(LocationName, Hardware, string, CallSettings)

public virtual Operation<Hardware, OperationMetadata> CreateHardware(LocationName parent, Hardware hardware, string hardwareId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Hardware hardware = new Hardware();
string hardwareId = "";
// Make the request
Operation<Hardware, OperationMetadata> response = gDCHardwareManagementClient.CreateHardware(parent, hardware, hardwareId);

// Poll until the returned long-running operation is complete
Operation<Hardware, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Hardware result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Hardware, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateHardware(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Hardware retrievedResult = retrievedResponse.Result;
}

CreateHardware(CreateHardwareRequest, CallSettings)

public virtual Operation<Hardware, OperationMetadata> CreateHardware(CreateHardwareRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
CreateHardwareRequest request = new CreateHardwareRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    HardwareId = "",
    Hardware = new Hardware(),
};
// Make the request
Operation<Hardware, OperationMetadata> response = gDCHardwareManagementClient.CreateHardware(request);

// Poll until the returned long-running operation is complete
Operation<Hardware, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Hardware result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Hardware, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateHardware(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Hardware retrievedResult = retrievedResponse.Result;
}

CreateHardware(string, Hardware, string, CallSettings)

public virtual Operation<Hardware, OperationMetadata> CreateHardware(string parent, Hardware hardware, string hardwareId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Hardware hardware = new Hardware();
string hardwareId = "";
// Make the request
Operation<Hardware, OperationMetadata> response = gDCHardwareManagementClient.CreateHardware(parent, hardware, hardwareId);

// Poll until the returned long-running operation is complete
Operation<Hardware, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Hardware result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Hardware, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateHardware(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Hardware retrievedResult = retrievedResponse.Result;
}

CreateHardwareAsync(LocationName, Hardware, string, CallSettings)

public virtual Task<Operation<Hardware, OperationMetadata>> CreateHardwareAsync(LocationName parent, Hardware hardware, string hardwareId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Hardware hardware = new Hardware();
string hardwareId = "";
// Make the request
Operation<Hardware, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareAsync(parent, hardware, hardwareId);

// Poll until the returned long-running operation is complete
Operation<Hardware, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Hardware result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Hardware, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Hardware retrievedResult = retrievedResponse.Result;
}

CreateHardwareAsync(LocationName, Hardware, string, CancellationToken)

public virtual Task<Operation<Hardware, OperationMetadata>> CreateHardwareAsync(LocationName parent, Hardware hardware, string hardwareId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Hardware hardware = new Hardware();
string hardwareId = "";
// Make the request
Operation<Hardware, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareAsync(parent, hardware, hardwareId);

// Poll until the returned long-running operation is complete
Operation<Hardware, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Hardware result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Hardware, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Hardware retrievedResult = retrievedResponse.Result;
}

CreateHardwareAsync(CreateHardwareRequest, CallSettings)

public virtual Task<Operation<Hardware, OperationMetadata>> CreateHardwareAsync(CreateHardwareRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateHardwareRequest request = new CreateHardwareRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    HardwareId = "",
    Hardware = new Hardware(),
};
// Make the request
Operation<Hardware, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareAsync(request);

// Poll until the returned long-running operation is complete
Operation<Hardware, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Hardware result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Hardware, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Hardware retrievedResult = retrievedResponse.Result;
}

CreateHardwareAsync(CreateHardwareRequest, CancellationToken)

public virtual Task<Operation<Hardware, OperationMetadata>> CreateHardwareAsync(CreateHardwareRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateHardwareRequest request = new CreateHardwareRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    HardwareId = "",
    Hardware = new Hardware(),
};
// Make the request
Operation<Hardware, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareAsync(request);

// Poll until the returned long-running operation is complete
Operation<Hardware, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Hardware result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Hardware, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Hardware retrievedResult = retrievedResponse.Result;
}

CreateHardwareAsync(string, Hardware, string, CallSettings)

public virtual Task<Operation<Hardware, OperationMetadata>> CreateHardwareAsync(string parent, Hardware hardware, string hardwareId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Hardware hardware = new Hardware();
string hardwareId = "";
// Make the request
Operation<Hardware, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareAsync(parent, hardware, hardwareId);

// Poll until the returned long-running operation is complete
Operation<Hardware, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Hardware result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Hardware, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Hardware retrievedResult = retrievedResponse.Result;
}

CreateHardwareAsync(string, Hardware, string, CancellationToken)

public virtual Task<Operation<Hardware, OperationMetadata>> CreateHardwareAsync(string parent, Hardware hardware, string hardwareId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Hardware hardware = new Hardware();
string hardwareId = "";
// Make the request
Operation<Hardware, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareAsync(parent, hardware, hardwareId);

// Poll until the returned long-running operation is complete
Operation<Hardware, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Hardware result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Hardware, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Hardware retrievedResult = retrievedResponse.Result;
}

CreateHardwareGroup(CreateHardwareGroupRequest, CallSettings)

public virtual Operation<HardwareGroup, OperationMetadata> CreateHardwareGroup(CreateHardwareGroupRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
CreateHardwareGroupRequest request = new CreateHardwareGroupRequest
{
    ParentAsOrderName = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]"),
    HardwareGroupId = "",
    HardwareGroup = new HardwareGroup(),
    RequestId = "",
};
// Make the request
Operation<HardwareGroup, OperationMetadata> response = gDCHardwareManagementClient.CreateHardwareGroup(request);

// Poll until the returned long-running operation is complete
Operation<HardwareGroup, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
HardwareGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<HardwareGroup, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateHardwareGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    HardwareGroup retrievedResult = retrievedResponse.Result;
}

CreateHardwareGroup(OrderName, HardwareGroup, string, CallSettings)

public virtual Operation<HardwareGroup, OperationMetadata> CreateHardwareGroup(OrderName parent, HardwareGroup hardwareGroup, string hardwareGroupId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
OrderName parent = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]");
HardwareGroup hardwareGroup = new HardwareGroup();
string hardwareGroupId = "";
// Make the request
Operation<HardwareGroup, OperationMetadata> response = gDCHardwareManagementClient.CreateHardwareGroup(parent, hardwareGroup, hardwareGroupId);

// Poll until the returned long-running operation is complete
Operation<HardwareGroup, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
HardwareGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<HardwareGroup, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateHardwareGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    HardwareGroup retrievedResult = retrievedResponse.Result;
}

CreateHardwareGroup(string, HardwareGroup, string, CallSettings)

public virtual Operation<HardwareGroup, OperationMetadata> CreateHardwareGroup(string parent, HardwareGroup hardwareGroup, string hardwareGroupId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]";
HardwareGroup hardwareGroup = new HardwareGroup();
string hardwareGroupId = "";
// Make the request
Operation<HardwareGroup, OperationMetadata> response = gDCHardwareManagementClient.CreateHardwareGroup(parent, hardwareGroup, hardwareGroupId);

// Poll until the returned long-running operation is complete
Operation<HardwareGroup, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
HardwareGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<HardwareGroup, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateHardwareGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    HardwareGroup retrievedResult = retrievedResponse.Result;
}

CreateHardwareGroupAsync(CreateHardwareGroupRequest, CallSettings)

public virtual Task<Operation<HardwareGroup, OperationMetadata>> CreateHardwareGroupAsync(CreateHardwareGroupRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateHardwareGroupRequest request = new CreateHardwareGroupRequest
{
    ParentAsOrderName = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]"),
    HardwareGroupId = "",
    HardwareGroup = new HardwareGroup(),
    RequestId = "",
};
// Make the request
Operation<HardwareGroup, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation<HardwareGroup, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
HardwareGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<HardwareGroup, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    HardwareGroup retrievedResult = retrievedResponse.Result;
}

CreateHardwareGroupAsync(CreateHardwareGroupRequest, CancellationToken)

public virtual Task<Operation<HardwareGroup, OperationMetadata>> CreateHardwareGroupAsync(CreateHardwareGroupRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateHardwareGroupRequest request = new CreateHardwareGroupRequest
{
    ParentAsOrderName = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]"),
    HardwareGroupId = "",
    HardwareGroup = new HardwareGroup(),
    RequestId = "",
};
// Make the request
Operation<HardwareGroup, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation<HardwareGroup, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
HardwareGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<HardwareGroup, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    HardwareGroup retrievedResult = retrievedResponse.Result;
}

CreateHardwareGroupAsync(OrderName, HardwareGroup, string, CallSettings)

public virtual Task<Operation<HardwareGroup, OperationMetadata>> CreateHardwareGroupAsync(OrderName parent, HardwareGroup hardwareGroup, string hardwareGroupId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
OrderName parent = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]");
HardwareGroup hardwareGroup = new HardwareGroup();
string hardwareGroupId = "";
// Make the request
Operation<HardwareGroup, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareGroupAsync(parent, hardwareGroup, hardwareGroupId);

// Poll until the returned long-running operation is complete
Operation<HardwareGroup, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
HardwareGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<HardwareGroup, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    HardwareGroup retrievedResult = retrievedResponse.Result;
}

CreateHardwareGroupAsync(OrderName, HardwareGroup, string, CancellationToken)

public virtual Task<Operation<HardwareGroup, OperationMetadata>> CreateHardwareGroupAsync(OrderName parent, HardwareGroup hardwareGroup, string hardwareGroupId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
OrderName parent = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]");
HardwareGroup hardwareGroup = new HardwareGroup();
string hardwareGroupId = "";
// Make the request
Operation<HardwareGroup, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareGroupAsync(parent, hardwareGroup, hardwareGroupId);

// Poll until the returned long-running operation is complete
Operation<HardwareGroup, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
HardwareGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<HardwareGroup, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    HardwareGroup retrievedResult = retrievedResponse.Result;
}

CreateHardwareGroupAsync(string, HardwareGroup, string, CallSettings)

public virtual Task<Operation<HardwareGroup, OperationMetadata>> CreateHardwareGroupAsync(string parent, HardwareGroup hardwareGroup, string hardwareGroupId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]";
HardwareGroup hardwareGroup = new HardwareGroup();
string hardwareGroupId = "";
// Make the request
Operation<HardwareGroup, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareGroupAsync(parent, hardwareGroup, hardwareGroupId);

// Poll until the returned long-running operation is complete
Operation<HardwareGroup, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
HardwareGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<HardwareGroup, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    HardwareGroup retrievedResult = retrievedResponse.Result;
}

CreateHardwareGroupAsync(string, HardwareGroup, string, CancellationToken)

public virtual Task<Operation<HardwareGroup, OperationMetadata>> CreateHardwareGroupAsync(string parent, HardwareGroup hardwareGroup, string hardwareGroupId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]";
HardwareGroup hardwareGroup = new HardwareGroup();
string hardwareGroupId = "";
// Make the request
Operation<HardwareGroup, OperationMetadata> response = await gDCHardwareManagementClient.CreateHardwareGroupAsync(parent, hardwareGroup, hardwareGroupId);

// Poll until the returned long-running operation is complete
Operation<HardwareGroup, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
HardwareGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<HardwareGroup, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    HardwareGroup retrievedResult = retrievedResponse.Result;
}

CreateOrder(LocationName, Order, string, CallSettings)

public virtual Operation<Order, OperationMetadata> CreateOrder(LocationName parent, Order order, string orderId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Order order = new Order();
string orderId = "";
// Make the request
Operation<Order, OperationMetadata> response = gDCHardwareManagementClient.CreateOrder(parent, order, orderId);

// Poll until the returned long-running operation is complete
Operation<Order, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Order result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Order, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateOrder(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Order retrievedResult = retrievedResponse.Result;
}

CreateOrder(CreateOrderRequest, CallSettings)

public virtual Operation<Order, OperationMetadata> CreateOrder(CreateOrderRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
CreateOrderRequest request = new CreateOrderRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    OrderId = "",
    Order = new Order(),
    RequestId = "",
};
// Make the request
Operation<Order, OperationMetadata> response = gDCHardwareManagementClient.CreateOrder(request);

// Poll until the returned long-running operation is complete
Operation<Order, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Order result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Order, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateOrder(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Order retrievedResult = retrievedResponse.Result;
}

CreateOrder(string, Order, string, CallSettings)

public virtual Operation<Order, OperationMetadata> CreateOrder(string parent, Order order, string orderId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Order order = new Order();
string orderId = "";
// Make the request
Operation<Order, OperationMetadata> response = gDCHardwareManagementClient.CreateOrder(parent, order, orderId);

// Poll until the returned long-running operation is complete
Operation<Order, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Order result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Order, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateOrder(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Order retrievedResult = retrievedResponse.Result;
}

CreateOrderAsync(LocationName, Order, string, CallSettings)

public virtual Task<Operation<Order, OperationMetadata>> CreateOrderAsync(LocationName parent, Order order, string orderId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Order order = new Order();
string orderId = "";
// Make the request
Operation<Order, OperationMetadata> response = await gDCHardwareManagementClient.CreateOrderAsync(parent, order, orderId);

// Poll until the returned long-running operation is complete
Operation<Order, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Order result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Order, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Order retrievedResult = retrievedResponse.Result;
}

CreateOrderAsync(LocationName, Order, string, CancellationToken)

public virtual Task<Operation<Order, OperationMetadata>> CreateOrderAsync(LocationName parent, Order order, string orderId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Order order = new Order();
string orderId = "";
// Make the request
Operation<Order, OperationMetadata> response = await gDCHardwareManagementClient.CreateOrderAsync(parent, order, orderId);

// Poll until the returned long-running operation is complete
Operation<Order, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Order result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Order, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Order retrievedResult = retrievedResponse.Result;
}

CreateOrderAsync(CreateOrderRequest, CallSettings)

public virtual Task<Operation<Order, OperationMetadata>> CreateOrderAsync(CreateOrderRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateOrderRequest request = new CreateOrderRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    OrderId = "",
    Order = new Order(),
    RequestId = "",
};
// Make the request
Operation<Order, OperationMetadata> response = await gDCHardwareManagementClient.CreateOrderAsync(request);

// Poll until the returned long-running operation is complete
Operation<Order, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Order result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Order, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Order retrievedResult = retrievedResponse.Result;
}

CreateOrderAsync(CreateOrderRequest, CancellationToken)

public virtual Task<Operation<Order, OperationMetadata>> CreateOrderAsync(CreateOrderRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateOrderRequest request = new CreateOrderRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    OrderId = "",
    Order = new Order(),
    RequestId = "",
};
// Make the request
Operation<Order, OperationMetadata> response = await gDCHardwareManagementClient.CreateOrderAsync(request);

// Poll until the returned long-running operation is complete
Operation<Order, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Order result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Order, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Order retrievedResult = retrievedResponse.Result;
}

CreateOrderAsync(string, Order, string, CallSettings)

public virtual Task<Operation<Order, OperationMetadata>> CreateOrderAsync(string parent, Order order, string orderId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Order order = new Order();
string orderId = "";
// Make the request
Operation<Order, OperationMetadata> response = await gDCHardwareManagementClient.CreateOrderAsync(parent, order, orderId);

// Poll until the returned long-running operation is complete
Operation<Order, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Order result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Order, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Order retrievedResult = retrievedResponse.Result;
}

CreateOrderAsync(string, Order, string, CancellationToken)

public virtual Task<Operation<Order, OperationMetadata>> CreateOrderAsync(string parent, Order order, string orderId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Order order = new Order();
string orderId = "";
// Make the request
Operation<Order, OperationMetadata> response = await gDCHardwareManagementClient.CreateOrderAsync(parent, order, orderId);

// Poll until the returned long-running operation is complete
Operation<Order, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Order result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Order, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Order retrievedResult = retrievedResponse.Result;
}

CreateSite(LocationName, Site, string, CallSettings)

public virtual Operation<Site, OperationMetadata> CreateSite(LocationName parent, Site site, string siteId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Site site = new Site();
string siteId = "";
// Make the request
Operation<Site, OperationMetadata> response = gDCHardwareManagementClient.CreateSite(parent, site, siteId);

// Poll until the returned long-running operation is complete
Operation<Site, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Site result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Site, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateSite(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Site retrievedResult = retrievedResponse.Result;
}

CreateSite(CreateSiteRequest, CallSettings)

public virtual Operation<Site, OperationMetadata> CreateSite(CreateSiteRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
CreateSiteRequest request = new CreateSiteRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    SiteId = "",
    Site = new Site(),
    RequestId = "",
};
// Make the request
Operation<Site, OperationMetadata> response = gDCHardwareManagementClient.CreateSite(request);

// Poll until the returned long-running operation is complete
Operation<Site, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Site result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Site, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateSite(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Site retrievedResult = retrievedResponse.Result;
}

CreateSite(string, Site, string, CallSettings)

public virtual Operation<Site, OperationMetadata> CreateSite(string parent, Site site, string siteId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Site site = new Site();
string siteId = "";
// Make the request
Operation<Site, OperationMetadata> response = gDCHardwareManagementClient.CreateSite(parent, site, siteId);

// Poll until the returned long-running operation is complete
Operation<Site, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Site result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Site, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateSite(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Site retrievedResult = retrievedResponse.Result;
}

CreateSiteAsync(LocationName, Site, string, CallSettings)

public virtual Task<Operation<Site, OperationMetadata>> CreateSiteAsync(LocationName parent, Site site, string siteId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Site site = new Site();
string siteId = "";
// Make the request
Operation<Site, OperationMetadata> response = await gDCHardwareManagementClient.CreateSiteAsync(parent, site, siteId);

// Poll until the returned long-running operation is complete
Operation<Site, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Site result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Site, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateSiteAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Site retrievedResult = retrievedResponse.Result;
}

CreateSiteAsync(LocationName, Site, string, CancellationToken)

public virtual Task<Operation<Site, OperationMetadata>> CreateSiteAsync(LocationName parent, Site site, string siteId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Site site = new Site();
string siteId = "";
// Make the request
Operation<Site, OperationMetadata> response = await gDCHardwareManagementClient.CreateSiteAsync(parent, site, siteId);

// Poll until the returned long-running operation is complete
Operation<Site, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Site result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Site, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateSiteAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Site retrievedResult = retrievedResponse.Result;
}

CreateSiteAsync(CreateSiteRequest, CallSettings)

public virtual Task<Operation<Site, OperationMetadata>> CreateSiteAsync(CreateSiteRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateSiteRequest request = new CreateSiteRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    SiteId = "",
    Site = new Site(),
    RequestId = "",
};
// Make the request
Operation<Site, OperationMetadata> response = await gDCHardwareManagementClient.CreateSiteAsync(request);

// Poll until the returned long-running operation is complete
Operation<Site, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Site result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Site, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateSiteAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Site retrievedResult = retrievedResponse.Result;
}

CreateSiteAsync(CreateSiteRequest, CancellationToken)

public virtual Task<Operation<Site, OperationMetadata>> CreateSiteAsync(CreateSiteRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateSiteRequest request = new CreateSiteRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    SiteId = "",
    Site = new Site(),
    RequestId = "",
};
// Make the request
Operation<Site, OperationMetadata> response = await gDCHardwareManagementClient.CreateSiteAsync(request);

// Poll until the returned long-running operation is complete
Operation<Site, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Site result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Site, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateSiteAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Site retrievedResult = retrievedResponse.Result;
}

CreateSiteAsync(string, Site, string, CallSettings)

public virtual Task<Operation<Site, OperationMetadata>> CreateSiteAsync(string parent, Site site, string siteId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Site site = new Site();
string siteId = "";
// Make the request
Operation<Site, OperationMetadata> response = await gDCHardwareManagementClient.CreateSiteAsync(parent, site, siteId);

// Poll until the returned long-running operation is complete
Operation<Site, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Site result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Site, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateSiteAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Site retrievedResult = retrievedResponse.Result;
}

CreateSiteAsync(string, Site, string, CancellationToken)

public virtual Task<Operation<Site, OperationMetadata>> CreateSiteAsync(string parent, Site site, string siteId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Site site = new Site();
string siteId = "";
// Make the request
Operation<Site, OperationMetadata> response = await gDCHardwareManagementClient.CreateSiteAsync(parent, site, siteId);

// Poll until the returned long-running operation is complete
Operation<Site, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Site result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Site, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateSiteAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Site retrievedResult = retrievedResponse.Result;
}

CreateZone(LocationName, Zone, string, CallSettings)

public virtual Operation<Zone, OperationMetadata> CreateZone(LocationName parent, Zone zone, string zoneId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = gDCHardwareManagementClient.CreateZone(parent, zone, zoneId);

// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Zone result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Zone, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateZone(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Zone retrievedResult = retrievedResponse.Result;
}

CreateZone(CreateZoneRequest, CallSettings)

public virtual Operation<Zone, OperationMetadata> CreateZone(CreateZoneRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
CreateZoneRequest request = new CreateZoneRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ZoneId = "",
    Zone = new Zone(),
    RequestId = "",
};
// Make the request
Operation<Zone, OperationMetadata> response = gDCHardwareManagementClient.CreateZone(request);

// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Zone result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Zone, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateZone(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Zone retrievedResult = retrievedResponse.Result;
}

CreateZone(string, Zone, string, CallSettings)

public virtual Operation<Zone, OperationMetadata> CreateZone(string parent, Zone zone, string zoneId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = gDCHardwareManagementClient.CreateZone(parent, zone, zoneId);

// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Zone result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Zone, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceCreateZone(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(LocationName, Zone, string, CallSettings)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(LocationName parent, Zone zone, string zoneId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = await gDCHardwareManagementClient.CreateZoneAsync(parent, zone, zoneId);

// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Zone result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Zone, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(LocationName, Zone, string, CancellationToken)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(LocationName parent, Zone zone, string zoneId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = await gDCHardwareManagementClient.CreateZoneAsync(parent, zone, zoneId);

// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Zone result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Zone, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(CreateZoneRequest, CallSettings)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(CreateZoneRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateZoneRequest request = new CreateZoneRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ZoneId = "",
    Zone = new Zone(),
    RequestId = "",
};
// Make the request
Operation<Zone, OperationMetadata> response = await gDCHardwareManagementClient.CreateZoneAsync(request);

// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Zone result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Zone, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(CreateZoneRequest, CancellationToken)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(CreateZoneRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CreateZoneRequest request = new CreateZoneRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ZoneId = "",
    Zone = new Zone(),
    RequestId = "",
};
// Make the request
Operation<Zone, OperationMetadata> response = await gDCHardwareManagementClient.CreateZoneAsync(request);

// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Zone result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Zone, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(string, Zone, string, CallSettings)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(string parent, Zone zone, string zoneId, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = await gDCHardwareManagementClient.CreateZoneAsync(parent, zone, zoneId);

// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Zone result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Zone, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(string, Zone, string, CancellationToken)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(string parent, Zone zone, string zoneId, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = await gDCHardwareManagementClient.CreateZoneAsync(parent, zone, zoneId);

// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Zone result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Zone, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Zone retrievedResult = retrievedResponse.Result;
}

DeleteHardware(DeleteHardwareRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteHardware(DeleteHardwareRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
DeleteHardwareRequest request = new DeleteHardwareRequest
{
    HardwareName = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteHardware(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteHardware(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardware(HardwareName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteHardware(HardwareName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
HardwareName name = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]");
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteHardware(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteHardware(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardware(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteHardware(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/hardware/[HARDWARE]";
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteHardware(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteHardware(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareAsync(DeleteHardwareRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareAsync(DeleteHardwareRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
DeleteHardwareRequest request = new DeleteHardwareRequest
{
    HardwareName = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareAsync(DeleteHardwareRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareAsync(DeleteHardwareRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
DeleteHardwareRequest request = new DeleteHardwareRequest
{
    HardwareName = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareAsync(HardwareName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareAsync(HardwareName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
HardwareName name = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]");
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareAsync(HardwareName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareAsync(HardwareName name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
HardwareName name = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]");
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareAsync(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/hardware/[HARDWARE]";
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareAsync(string name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/hardware/[HARDWARE]";
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareGroup(DeleteHardwareGroupRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteHardwareGroup(DeleteHardwareGroupRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
DeleteHardwareGroupRequest request = new DeleteHardwareGroupRequest
{
    HardwareGroupName = HardwareGroupName.FromProjectLocationOrderHardwareGroup("[PROJECT]", "[LOCATION]", "[ORDER]", "[HARDWARE_GROUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteHardwareGroup(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteHardwareGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareGroup(HardwareGroupName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteHardwareGroup(HardwareGroupName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
HardwareGroupName name = HardwareGroupName.FromProjectLocationOrderHardwareGroup("[PROJECT]", "[LOCATION]", "[ORDER]", "[HARDWARE_GROUP]");
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteHardwareGroup(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteHardwareGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareGroup(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteHardwareGroup(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]/hardwareGroups/[HARDWARE_GROUP]";
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteHardwareGroup(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteHardwareGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareGroupAsync(DeleteHardwareGroupRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareGroupAsync(DeleteHardwareGroupRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
DeleteHardwareGroupRequest request = new DeleteHardwareGroupRequest
{
    HardwareGroupName = HardwareGroupName.FromProjectLocationOrderHardwareGroup("[PROJECT]", "[LOCATION]", "[ORDER]", "[HARDWARE_GROUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareGroupAsync(DeleteHardwareGroupRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareGroupAsync(DeleteHardwareGroupRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
DeleteHardwareGroupRequest request = new DeleteHardwareGroupRequest
{
    HardwareGroupName = HardwareGroupName.FromProjectLocationOrderHardwareGroup("[PROJECT]", "[LOCATION]", "[ORDER]", "[HARDWARE_GROUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareGroupAsync(HardwareGroupName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareGroupAsync(HardwareGroupName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
HardwareGroupName name = HardwareGroupName.FromProjectLocationOrderHardwareGroup("[PROJECT]", "[LOCATION]", "[ORDER]", "[HARDWARE_GROUP]");
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareGroupAsync(HardwareGroupName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareGroupAsync(HardwareGroupName name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
HardwareGroupName name = HardwareGroupName.FromProjectLocationOrderHardwareGroup("[PROJECT]", "[LOCATION]", "[ORDER]", "[HARDWARE_GROUP]");
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareGroupAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareGroupAsync(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]/hardwareGroups/[HARDWARE_GROUP]";
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteHardwareGroupAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteHardwareGroupAsync(string name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]/hardwareGroups/[HARDWARE_GROUP]";
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteHardwareGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteHardwareGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteOrder(DeleteOrderRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteOrder(DeleteOrderRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
DeleteOrderRequest request = new DeleteOrderRequest
{
    OrderName = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteOrder(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteOrder(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteOrder(OrderName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteOrder(OrderName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
OrderName name = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]");
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteOrder(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteOrder(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteOrder(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteOrder(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]";
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteOrder(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteOrder(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteOrderAsync(DeleteOrderRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteOrderAsync(DeleteOrderRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
DeleteOrderRequest request = new DeleteOrderRequest
{
    OrderName = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteOrderAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteOrderAsync(DeleteOrderRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteOrderAsync(DeleteOrderRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
DeleteOrderRequest request = new DeleteOrderRequest
{
    OrderName = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteOrderAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteOrderAsync(OrderName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteOrderAsync(OrderName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
OrderName name = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]");
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteOrderAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteOrderAsync(OrderName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteOrderAsync(OrderName name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
OrderName name = OrderName.FromProjectLocationOrder("[PROJECT]", "[LOCATION]", "[ORDER]");
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteOrderAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteOrderAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteOrderAsync(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]";
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteOrderAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteOrderAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteOrderAsync(string name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]";
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteOrderAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteOrderAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteZone(DeleteZoneRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteZone(DeleteZoneRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
DeleteZoneRequest request = new DeleteZoneRequest
{
    ZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteZone(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteZone(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteZone(ZoneName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteZone(ZoneName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
ZoneName name = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteZone(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteZone(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteZone(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteZone(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
// Make the request
Operation<Empty, OperationMetadata> response = gDCHardwareManagementClient.DeleteZone(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = gDCHardwareManagementClient.PollOnceDeleteZone(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteZoneAsync(DeleteZoneRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteZoneAsync(DeleteZoneRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
DeleteZoneRequest request = new DeleteZoneRequest
{
    ZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteZoneAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteZoneAsync(DeleteZoneRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteZoneAsync(DeleteZoneRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
DeleteZoneRequest request = new DeleteZoneRequest
{
    ZoneName = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteZoneAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteZoneAsync(ZoneName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteZoneAsync(ZoneName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
ZoneName name = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteZoneAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteZoneAsync(ZoneName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteZoneAsync(ZoneName name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
ZoneName name = ZoneName.FromProjectLocationZone("[PROJECT]", "[LOCATION]", "[ZONE]");
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteZoneAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteZoneAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteZoneAsync(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteZoneAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteZoneAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteZoneAsync(string name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/zones/[ZONE]";
// Make the request
Operation<Empty, OperationMetadata> response = await gDCHardwareManagementClient.DeleteZoneAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await gDCHardwareManagementClient.PollOnceDeleteZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

GetChangeLogEntry(ChangeLogEntryName, CallSettings)

public virtual ChangeLogEntry GetChangeLogEntry(ChangeLogEntryName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
ChangeLogEntryName name = ChangeLogEntryName.FromProjectLocationOrderChangeLogEntry("[PROJECT]", "[LOCATION]", "[ORDER]", "[CHANGE_LOG_ENTRY]");
// Make the request
ChangeLogEntry response = gDCHardwareManagementClient.GetChangeLogEntry(name);

GetChangeLogEntry(GetChangeLogEntryRequest, CallSettings)

public virtual ChangeLogEntry GetChangeLogEntry(GetChangeLogEntryRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
GetChangeLogEntryRequest request = new GetChangeLogEntryRequest
{
    ChangeLogEntryName = ChangeLogEntryName.FromProjectLocationOrderChangeLogEntry("[PROJECT]", "[LOCATION]", "[ORDER]", "[CHANGE_LOG_ENTRY]"),
};
// Make the request
ChangeLogEntry response = gDCHardwareManagementClient.GetChangeLogEntry(request);

GetChangeLogEntry(string, CallSettings)

public virtual ChangeLogEntry GetChangeLogEntry(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]/changeLogEntries/[CHANGE_LOG_ENTRY]";
// Make the request
ChangeLogEntry response = gDCHardwareManagementClient.GetChangeLogEntry(name);

GetChangeLogEntryAsync(ChangeLogEntryName, CallSettings)

public virtual Task<ChangeLogEntry> GetChangeLogEntryAsync(ChangeLogEntryName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
ChangeLogEntryName name = ChangeLogEntryName.FromProjectLocationOrderChangeLogEntry("[PROJECT]", "[LOCATION]", "[ORDER]", "[CHANGE_LOG_ENTRY]");
// Make the request
ChangeLogEntry response = await gDCHardwareManagementClient.GetChangeLogEntryAsync(name);

GetChangeLogEntryAsync(ChangeLogEntryName, CancellationToken)

public virtual Task<ChangeLogEntry> GetChangeLogEntryAsync(ChangeLogEntryName name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
ChangeLogEntryName name = ChangeLogEntryName.FromProjectLocationOrderChangeLogEntry("[PROJECT]", "[LOCATION]", "[ORDER]", "[CHANGE_LOG_ENTRY]");
// Make the request
ChangeLogEntry response = await gDCHardwareManagementClient.GetChangeLogEntryAsync(name);

GetChangeLogEntryAsync(GetChangeLogEntryRequest, CallSettings)

public virtual Task<ChangeLogEntry> GetChangeLogEntryAsync(GetChangeLogEntryRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
GetChangeLogEntryRequest request = new GetChangeLogEntryRequest
{
    ChangeLogEntryName = ChangeLogEntryName.FromProjectLocationOrderChangeLogEntry("[PROJECT]", "[LOCATION]", "[ORDER]", "[CHANGE_LOG_ENTRY]"),
};
// Make the request
ChangeLogEntry response = await gDCHardwareManagementClient.GetChangeLogEntryAsync(request);

GetChangeLogEntryAsync(GetChangeLogEntryRequest, CancellationToken)

public virtual Task<ChangeLogEntry> GetChangeLogEntryAsync(GetChangeLogEntryRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
GetChangeLogEntryRequest request = new GetChangeLogEntryRequest
{
    ChangeLogEntryName = ChangeLogEntryName.FromProjectLocationOrderChangeLogEntry("[PROJECT]", "[LOCATION]", "[ORDER]", "[CHANGE_LOG_ENTRY]"),
};
// Make the request
ChangeLogEntry response = await gDCHardwareManagementClient.GetChangeLogEntryAsync(request);

GetChangeLogEntryAsync(string, CallSettings)

public virtual Task<ChangeLogEntry> GetChangeLogEntryAsync(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]/changeLogEntries/[CHANGE_LOG_ENTRY]";
// Make the request
ChangeLogEntry response = await gDCHardwareManagementClient.GetChangeLogEntryAsync(name);

GetChangeLogEntryAsync(string, CancellationToken)

public virtual Task<ChangeLogEntry> GetChangeLogEntryAsync(string name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]/changeLogEntries/[CHANGE_LOG_ENTRY]";
// Make the request
ChangeLogEntry response = await gDCHardwareManagementClient.GetChangeLogEntryAsync(name);

GetComment(CommentName, CallSettings)

public virtual Comment GetComment(CommentName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
CommentName name = CommentName.FromProjectLocationOrderComment("[PROJECT]", "[LOCATION]", "[ORDER]", "[COMMENT]");
// Make the request
Comment response = gDCHardwareManagementClient.GetComment(name);

GetComment(GetCommentRequest, CallSettings)

public virtual Comment GetComment(GetCommentRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
GetCommentRequest request = new GetCommentRequest
{
    CommentName = CommentName.FromProjectLocationOrderComment("[PROJECT]", "[LOCATION]", "[ORDER]", "[COMMENT]"),
};
// Make the request
Comment response = gDCHardwareManagementClient.GetComment(request);

GetComment(string, CallSettings)

public virtual Comment GetComment(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]/comments/[COMMENT]";
// Make the request
Comment response = gDCHardwareManagementClient.GetComment(name);

GetCommentAsync(CommentName, CallSettings)

public virtual Task<Comment> GetCommentAsync(CommentName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CommentName name = CommentName.FromProjectLocationOrderComment("[PROJECT]", "[LOCATION]", "[ORDER]", "[COMMENT]");
// Make the request
Comment response = await gDCHardwareManagementClient.GetCommentAsync(name);

GetCommentAsync(CommentName, CancellationToken)

public virtual Task<Comment> GetCommentAsync(CommentName name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
CommentName name = CommentName.FromProjectLocationOrderComment("[PROJECT]", "[LOCATION]", "[ORDER]", "[COMMENT]");
// Make the request
Comment response = await gDCHardwareManagementClient.GetCommentAsync(name);

GetCommentAsync(GetCommentRequest, CallSettings)

public virtual Task<Comment> GetCommentAsync(GetCommentRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
GetCommentRequest request = new GetCommentRequest
{
    CommentName = CommentName.FromProjectLocationOrderComment("[PROJECT]", "[LOCATION]", "[ORDER]", "[COMMENT]"),
};
// Make the request
Comment response = await gDCHardwareManagementClient.GetCommentAsync(request);

GetCommentAsync(GetCommentRequest, CancellationToken)

public virtual Task<Comment> GetCommentAsync(GetCommentRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
GetCommentRequest request = new GetCommentRequest
{
    CommentName = CommentName.FromProjectLocationOrderComment("[PROJECT]", "[LOCATION]", "[ORDER]", "[COMMENT]"),
};
// Make the request
Comment response = await gDCHardwareManagementClient.GetCommentAsync(request);

GetCommentAsync(string, CallSettings)

public virtual Task<Comment> GetCommentAsync(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]/comments/[COMMENT]";
// Make the request
Comment response = await gDCHardwareManagementClient.GetCommentAsync(name);

GetCommentAsync(string, CancellationToken)

public virtual Task<Comment> GetCommentAsync(string name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/orders/[ORDER]/comments/[COMMENT]";
// Make the request
Comment response = await gDCHardwareManagementClient.GetCommentAsync(name);

GetHardware(GetHardwareRequest, CallSettings)

public virtual Hardware GetHardware(GetHardwareRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
GetHardwareRequest request = new GetHardwareRequest
{
    HardwareName = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]"),
};
// Make the request
Hardware response = gDCHardwareManagementClient.GetHardware(request);

GetHardware(HardwareName, CallSettings)

public virtual Hardware GetHardware(HardwareName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
HardwareName name = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]");
// Make the request
Hardware response = gDCHardwareManagementClient.GetHardware(name);

GetHardware(string, CallSettings)

public virtual Hardware GetHardware(string name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = GDCHardwareManagementClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/hardware/[HARDWARE]";
// Make the request
Hardware response = gDCHardwareManagementClient.GetHardware(name);

GetHardwareAsync(GetHardwareRequest, CallSettings)

public virtual Task<Hardware> GetHardwareAsync(GetHardwareRequest request, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
GetHardwareRequest request = new GetHardwareRequest
{
    HardwareName = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]"),
};
// Make the request
Hardware response = await gDCHardwareManagementClient.GetHardwareAsync(request);

GetHardwareAsync(GetHardwareRequest, CancellationToken)

public virtual Task<Hardware> GetHardwareAsync(GetHardwareRequest request, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
GetHardwareRequest request = new GetHardwareRequest
{
    HardwareName = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]"),
};
// Make the request
Hardware response = await gDCHardwareManagementClient.GetHardwareAsync(request);

GetHardwareAsync(HardwareName, CallSettings)

public virtual Task<Hardware> GetHardwareAsync(HardwareName name, CallSettings callSettings = null)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
HardwareName name = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]");
// Make the request
Hardware response = await gDCHardwareManagementClient.GetHardwareAsync(name);

GetHardwareAsync(HardwareName, CancellationToken)

public virtual Task<Hardware> GetHardwareAsync(HardwareName name, CancellationToken cancellationToken)

// Create client
GDCHardwareManagementClient gDCHardwareManagementClient = await GDCHardwareManagementClient.CreateAsync();
// Initialize request argument(s)
HardwareName name = HardwareName.FromProjectLocationHardware("[PROJECT]", "[LOCATION]", "[HARDWARE]");
// Make the request
Hardware response = await gDCHardwareManagementClient.GetHardwareAsync(name);

GetHardwareAsync(string, CallSettings)

public virtual Task<Hardware> GetHardwareAsync(string name, CallSettings callSettings = null)