Certificate Authority v1 API - Class CertificateAuthorityServiceClient (3.5.0)

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
ActivateCertificateAuthorityRequest request = new ActivateCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    PemCaCertificate = "",
    SubordinateConfig = new SubordinateConfig(),
    RequestId = "",
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.ActivateCertificateAuthority(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceActivateCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.ActivateCertificateAuthority(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceActivateCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.ActivateCertificateAuthority(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceActivateCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
ActivateCertificateAuthorityRequest request = new ActivateCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    PemCaCertificate = "",
    SubordinateConfig = new SubordinateConfig(),
    RequestId = "",
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.ActivateCertificateAuthorityAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceActivateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
ActivateCertificateAuthorityRequest request = new ActivateCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    PemCaCertificate = "",
    SubordinateConfig = new SubordinateConfig(),
    RequestId = "",
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.ActivateCertificateAuthorityAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceActivateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.ActivateCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceActivateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.ActivateCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceActivateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.ActivateCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceActivateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.ActivateCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceActivateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CaPool caPool = new CaPool();
string caPoolId = "";
// Make the request
Operation<CaPool, OperationMetadata> response = certificateAuthorityServiceClient.CreateCaPool(parent, caPool, caPoolId);

// Poll until the returned long-running operation is complete
Operation<CaPool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CaPool 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<CaPool, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceCreateCaPool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CaPool retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CreateCaPoolRequest request = new CreateCaPoolRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CaPoolId = "",
    CaPool = new CaPool(),
    RequestId = "",
};
// Make the request
Operation<CaPool, OperationMetadata> response = certificateAuthorityServiceClient.CreateCaPool(request);

// Poll until the returned long-running operation is complete
Operation<CaPool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CaPool 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<CaPool, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceCreateCaPool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CaPool retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CaPool caPool = new CaPool();
string caPoolId = "";
// Make the request
Operation<CaPool, OperationMetadata> response = certificateAuthorityServiceClient.CreateCaPool(parent, caPool, caPoolId);

// Poll until the returned long-running operation is complete
Operation<CaPool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CaPool 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<CaPool, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceCreateCaPool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CaPool retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CaPool caPool = new CaPool();
string caPoolId = "";
// Make the request
Operation<CaPool, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCaPoolAsync(parent, caPool, caPoolId);

// Poll until the returned long-running operation is complete
Operation<CaPool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CaPool 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<CaPool, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCaPoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CaPool retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CaPool caPool = new CaPool();
string caPoolId = "";
// Make the request
Operation<CaPool, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCaPoolAsync(parent, caPool, caPoolId);

// Poll until the returned long-running operation is complete
Operation<CaPool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CaPool 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<CaPool, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCaPoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CaPool retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CreateCaPoolRequest request = new CreateCaPoolRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CaPoolId = "",
    CaPool = new CaPool(),
    RequestId = "",
};
// Make the request
Operation<CaPool, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCaPoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<CaPool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CaPool 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<CaPool, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCaPoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CaPool retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CreateCaPoolRequest request = new CreateCaPoolRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CaPoolId = "",
    CaPool = new CaPool(),
    RequestId = "",
};
// Make the request
Operation<CaPool, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCaPoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<CaPool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CaPool 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<CaPool, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCaPoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CaPool retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CaPool caPool = new CaPool();
string caPoolId = "";
// Make the request
Operation<CaPool, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCaPoolAsync(parent, caPool, caPoolId);

// Poll until the returned long-running operation is complete
Operation<CaPool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CaPool 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<CaPool, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCaPoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CaPool retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CaPool caPool = new CaPool();
string caPoolId = "";
// Make the request
Operation<CaPool, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCaPoolAsync(parent, caPool, caPoolId);

// Poll until the returned long-running operation is complete
Operation<CaPool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CaPool 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<CaPool, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCaPoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CaPool retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CaPoolName parent = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
Certificate certificate = new Certificate();
string certificateId = "";
// Make the request
Certificate response = certificateAuthorityServiceClient.CreateCertificate(parent, certificate, certificateId);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CreateCertificateRequest request = new CreateCertificateRequest
{
    ParentAsCaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    CertificateId = "",
    Certificate = new Certificate(),
    RequestId = "",
    ValidateOnly = false,
    IssuingCertificateAuthorityId = "",
};
// Make the request
Certificate response = certificateAuthorityServiceClient.CreateCertificate(request);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
Certificate certificate = new Certificate();
string certificateId = "";
// Make the request
Certificate response = certificateAuthorityServiceClient.CreateCertificate(parent, certificate, certificateId);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CaPoolName parent = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
Certificate certificate = new Certificate();
string certificateId = "";
// Make the request
Certificate response = await certificateAuthorityServiceClient.CreateCertificateAsync(parent, certificate, certificateId);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CaPoolName parent = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
Certificate certificate = new Certificate();
string certificateId = "";
// Make the request
Certificate response = await certificateAuthorityServiceClient.CreateCertificateAsync(parent, certificate, certificateId);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CreateCertificateRequest request = new CreateCertificateRequest
{
    ParentAsCaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    CertificateId = "",
    Certificate = new Certificate(),
    RequestId = "",
    ValidateOnly = false,
    IssuingCertificateAuthorityId = "",
};
// Make the request
Certificate response = await certificateAuthorityServiceClient.CreateCertificateAsync(request);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CreateCertificateRequest request = new CreateCertificateRequest
{
    ParentAsCaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    CertificateId = "",
    Certificate = new Certificate(),
    RequestId = "",
    ValidateOnly = false,
    IssuingCertificateAuthorityId = "",
};
// Make the request
Certificate response = await certificateAuthorityServiceClient.CreateCertificateAsync(request);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
Certificate certificate = new Certificate();
string certificateId = "";
// Make the request
Certificate response = await certificateAuthorityServiceClient.CreateCertificateAsync(parent, certificate, certificateId);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
Certificate certificate = new Certificate();
string certificateId = "";
// Make the request
Certificate response = await certificateAuthorityServiceClient.CreateCertificateAsync(parent, certificate, certificateId);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CaPoolName parent = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
CertificateAuthority certificateAuthority = new CertificateAuthority();
string certificateAuthorityId = "";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.CreateCertificateAuthority(parent, certificateAuthority, certificateAuthorityId);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceCreateCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CreateCertificateAuthorityRequest request = new CreateCertificateAuthorityRequest
{
    ParentAsCaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    CertificateAuthorityId = "",
    CertificateAuthority = new CertificateAuthority(),
    RequestId = "",
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.CreateCertificateAuthority(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceCreateCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
CertificateAuthority certificateAuthority = new CertificateAuthority();
string certificateAuthorityId = "";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.CreateCertificateAuthority(parent, certificateAuthority, certificateAuthorityId);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceCreateCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CaPoolName parent = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
CertificateAuthority certificateAuthority = new CertificateAuthority();
string certificateAuthorityId = "";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateAuthorityAsync(parent, certificateAuthority, certificateAuthorityId);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CaPoolName parent = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
CertificateAuthority certificateAuthority = new CertificateAuthority();
string certificateAuthorityId = "";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateAuthorityAsync(parent, certificateAuthority, certificateAuthorityId);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CreateCertificateAuthorityRequest request = new CreateCertificateAuthorityRequest
{
    ParentAsCaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    CertificateAuthorityId = "",
    CertificateAuthority = new CertificateAuthority(),
    RequestId = "",
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateAuthorityAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CreateCertificateAuthorityRequest request = new CreateCertificateAuthorityRequest
{
    ParentAsCaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    CertificateAuthorityId = "",
    CertificateAuthority = new CertificateAuthority(),
    RequestId = "",
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateAuthorityAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
CertificateAuthority certificateAuthority = new CertificateAuthority();
string certificateAuthorityId = "";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateAuthorityAsync(parent, certificateAuthority, certificateAuthorityId);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
CertificateAuthority certificateAuthority = new CertificateAuthority();
string certificateAuthorityId = "";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateAuthorityAsync(parent, certificateAuthority, certificateAuthorityId);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CertificateTemplate certificateTemplate = new CertificateTemplate();
string certificateTemplateId = "";
// Make the request
Operation<CertificateTemplate, OperationMetadata> response = certificateAuthorityServiceClient.CreateCertificateTemplate(parent, certificateTemplate, certificateTemplateId);

// Poll until the returned long-running operation is complete
Operation<CertificateTemplate, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateTemplate 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<CertificateTemplate, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceCreateCertificateTemplate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CreateCertificateTemplateRequest request = new CreateCertificateTemplateRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CertificateTemplateId = "",
    CertificateTemplate = new CertificateTemplate(),
    RequestId = "",
};
// Make the request
Operation<CertificateTemplate, OperationMetadata> response = certificateAuthorityServiceClient.CreateCertificateTemplate(request);

// Poll until the returned long-running operation is complete
Operation<CertificateTemplate, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateTemplate 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<CertificateTemplate, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceCreateCertificateTemplate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CertificateTemplate certificateTemplate = new CertificateTemplate();
string certificateTemplateId = "";
// Make the request
Operation<CertificateTemplate, OperationMetadata> response = certificateAuthorityServiceClient.CreateCertificateTemplate(parent, certificateTemplate, certificateTemplateId);

// Poll until the returned long-running operation is complete
Operation<CertificateTemplate, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateTemplate 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<CertificateTemplate, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceCreateCertificateTemplate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CertificateTemplate certificateTemplate = new CertificateTemplate();
string certificateTemplateId = "";
// Make the request
Operation<CertificateTemplate, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateTemplateAsync(parent, certificateTemplate, certificateTemplateId);

// Poll until the returned long-running operation is complete
Operation<CertificateTemplate, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateTemplate 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<CertificateTemplate, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CertificateTemplate certificateTemplate = new CertificateTemplate();
string certificateTemplateId = "";
// Make the request
Operation<CertificateTemplate, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateTemplateAsync(parent, certificateTemplate, certificateTemplateId);

// Poll until the returned long-running operation is complete
Operation<CertificateTemplate, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateTemplate 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<CertificateTemplate, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CreateCertificateTemplateRequest request = new CreateCertificateTemplateRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CertificateTemplateId = "",
    CertificateTemplate = new CertificateTemplate(),
    RequestId = "",
};
// Make the request
Operation<CertificateTemplate, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateTemplateAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateTemplate, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateTemplate 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<CertificateTemplate, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CreateCertificateTemplateRequest request = new CreateCertificateTemplateRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CertificateTemplateId = "",
    CertificateTemplate = new CertificateTemplate(),
    RequestId = "",
};
// Make the request
Operation<CertificateTemplate, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateTemplateAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateTemplate, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateTemplate 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<CertificateTemplate, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CertificateTemplate certificateTemplate = new CertificateTemplate();
string certificateTemplateId = "";
// Make the request
Operation<CertificateTemplate, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateTemplateAsync(parent, certificateTemplate, certificateTemplateId);

// Poll until the returned long-running operation is complete
Operation<CertificateTemplate, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateTemplate 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<CertificateTemplate, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CertificateTemplate certificateTemplate = new CertificateTemplate();
string certificateTemplateId = "";
// Make the request
Operation<CertificateTemplate, OperationMetadata> response = await certificateAuthorityServiceClient.CreateCertificateTemplateAsync(parent, certificateTemplate, certificateTemplateId);

// Poll until the returned long-running operation is complete
Operation<CertificateTemplate, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateTemplate 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<CertificateTemplate, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceCreateCertificateTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CaPoolName name = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
// Make the request
Operation<Empty, OperationMetadata> response = certificateAuthorityServiceClient.DeleteCaPool(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 = certificateAuthorityServiceClient.PollOnceDeleteCaPool(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
DeleteCaPoolRequest request = new DeleteCaPoolRequest
{
    CaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    RequestId = "",
    IgnoreDependentResources = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = certificateAuthorityServiceClient.DeleteCaPool(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 = certificateAuthorityServiceClient.PollOnceDeleteCaPool(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
// Make the request
Operation<Empty, OperationMetadata> response = certificateAuthorityServiceClient.DeleteCaPool(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 = certificateAuthorityServiceClient.PollOnceDeleteCaPool(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CaPoolName name = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCaPoolAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCaPoolAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CaPoolName name = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCaPoolAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCaPoolAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteCaPoolRequest request = new DeleteCaPoolRequest
{
    CaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    RequestId = "",
    IgnoreDependentResources = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCaPoolAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCaPoolAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteCaPoolRequest request = new DeleteCaPoolRequest
{
    CaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    RequestId = "",
    IgnoreDependentResources = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCaPoolAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCaPoolAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCaPoolAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCaPoolAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCaPoolAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCaPoolAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.DeleteCertificateAuthority(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceDeleteCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
DeleteCertificateAuthorityRequest request = new DeleteCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    RequestId = "",
    IgnoreActiveCertificates = false,
    SkipGracePeriod = false,
    IgnoreDependentResources = false,
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.DeleteCertificateAuthority(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceDeleteCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.DeleteCertificateAuthority(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceDeleteCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDeleteCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDeleteCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteCertificateAuthorityRequest request = new DeleteCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    RequestId = "",
    IgnoreActiveCertificates = false,
    SkipGracePeriod = false,
    IgnoreDependentResources = false,
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateAuthorityAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDeleteCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteCertificateAuthorityRequest request = new DeleteCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    RequestId = "",
    IgnoreActiveCertificates = false,
    SkipGracePeriod = false,
    IgnoreDependentResources = false,
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateAuthorityAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDeleteCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDeleteCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDeleteCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CertificateTemplateName name = CertificateTemplateName.FromProjectLocationCertificateTemplate("[PROJECT]", "[LOCATION]", "[CERTIFICATE_TEMPLATE]");
// Make the request
Operation<Empty, OperationMetadata> response = certificateAuthorityServiceClient.DeleteCertificateTemplate(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 = certificateAuthorityServiceClient.PollOnceDeleteCertificateTemplate(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
DeleteCertificateTemplateRequest request = new DeleteCertificateTemplateRequest
{
    CertificateTemplateName = CertificateTemplateName.FromProjectLocationCertificateTemplate("[PROJECT]", "[LOCATION]", "[CERTIFICATE_TEMPLATE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = certificateAuthorityServiceClient.DeleteCertificateTemplate(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 = certificateAuthorityServiceClient.PollOnceDeleteCertificateTemplate(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/certificateTemplates/[CERTIFICATE_TEMPLATE]";
// Make the request
Operation<Empty, OperationMetadata> response = certificateAuthorityServiceClient.DeleteCertificateTemplate(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 = certificateAuthorityServiceClient.PollOnceDeleteCertificateTemplate(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateTemplateName name = CertificateTemplateName.FromProjectLocationCertificateTemplate("[PROJECT]", "[LOCATION]", "[CERTIFICATE_TEMPLATE]");
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateTemplateAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCertificateTemplateAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateTemplateName name = CertificateTemplateName.FromProjectLocationCertificateTemplate("[PROJECT]", "[LOCATION]", "[CERTIFICATE_TEMPLATE]");
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateTemplateAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCertificateTemplateAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteCertificateTemplateRequest request = new DeleteCertificateTemplateRequest
{
    CertificateTemplateName = CertificateTemplateName.FromProjectLocationCertificateTemplate("[PROJECT]", "[LOCATION]", "[CERTIFICATE_TEMPLATE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateTemplateAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCertificateTemplateAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteCertificateTemplateRequest request = new DeleteCertificateTemplateRequest
{
    CertificateTemplateName = CertificateTemplateName.FromProjectLocationCertificateTemplate("[PROJECT]", "[LOCATION]", "[CERTIFICATE_TEMPLATE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateTemplateAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCertificateTemplateAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/certificateTemplates/[CERTIFICATE_TEMPLATE]";
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateTemplateAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCertificateTemplateAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/certificateTemplates/[CERTIFICATE_TEMPLATE]";
// Make the request
Operation<Empty, OperationMetadata> response = await certificateAuthorityServiceClient.DeleteCertificateTemplateAsync(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 certificateAuthorityServiceClient.PollOnceDeleteCertificateTemplateAsync(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;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.DisableCertificateAuthority(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceDisableCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
DisableCertificateAuthorityRequest request = new DisableCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    RequestId = "",
    IgnoreDependentResources = false,
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.DisableCertificateAuthority(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceDisableCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.DisableCertificateAuthority(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceDisableCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DisableCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDisableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DisableCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDisableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
DisableCertificateAuthorityRequest request = new DisableCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    RequestId = "",
    IgnoreDependentResources = false,
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DisableCertificateAuthorityAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDisableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
DisableCertificateAuthorityRequest request = new DisableCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    RequestId = "",
    IgnoreDependentResources = false,
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DisableCertificateAuthorityAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDisableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DisableCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDisableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.DisableCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceDisableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.EnableCertificateAuthority(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceEnableCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
EnableCertificateAuthorityRequest request = new EnableCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    RequestId = "",
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.EnableCertificateAuthority(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceEnableCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = certificateAuthorityServiceClient.EnableCertificateAuthority(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = certificateAuthorityServiceClient.PollOnceEnableCertificateAuthority(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.EnableCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceEnableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.EnableCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceEnableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
EnableCertificateAuthorityRequest request = new EnableCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    RequestId = "",
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.EnableCertificateAuthorityAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceEnableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
EnableCertificateAuthorityRequest request = new EnableCertificateAuthorityRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
    RequestId = "",
};
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.EnableCertificateAuthorityAsync(request);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceEnableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.EnableCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceEnableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
Operation<CertificateAuthority, OperationMetadata> response = await certificateAuthorityServiceClient.EnableCertificateAuthorityAsync(name);

// Poll until the returned long-running operation is complete
Operation<CertificateAuthority, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
CertificateAuthority 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<CertificateAuthority, OperationMetadata> retrievedResponse = await certificateAuthorityServiceClient.PollOnceEnableCertificateAuthorityAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    CertificateAuthority retrievedResult = retrievedResponse.Result;
}

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CaPoolName caPool = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
// Make the request
FetchCaCertsResponse response = certificateAuthorityServiceClient.FetchCaCerts(caPool);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
FetchCaCertsRequest request = new FetchCaCertsRequest
{
    CaPoolAsCaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    RequestId = "",
};
// Make the request
FetchCaCertsResponse response = certificateAuthorityServiceClient.FetchCaCerts(request);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string caPool = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
// Make the request
FetchCaCertsResponse response = certificateAuthorityServiceClient.FetchCaCerts(caPool);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CaPoolName caPool = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
// Make the request
FetchCaCertsResponse response = await certificateAuthorityServiceClient.FetchCaCertsAsync(caPool);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CaPoolName caPool = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
// Make the request
FetchCaCertsResponse response = await certificateAuthorityServiceClient.FetchCaCertsAsync(caPool);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
FetchCaCertsRequest request = new FetchCaCertsRequest
{
    CaPoolAsCaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    RequestId = "",
};
// Make the request
FetchCaCertsResponse response = await certificateAuthorityServiceClient.FetchCaCertsAsync(request);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
FetchCaCertsRequest request = new FetchCaCertsRequest
{
    CaPoolAsCaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
    RequestId = "",
};
// Make the request
FetchCaCertsResponse response = await certificateAuthorityServiceClient.FetchCaCertsAsync(request);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string caPool = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
// Make the request
FetchCaCertsResponse response = await certificateAuthorityServiceClient.FetchCaCertsAsync(caPool);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string caPool = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
// Make the request
FetchCaCertsResponse response = await certificateAuthorityServiceClient.FetchCaCertsAsync(caPool);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
FetchCertificateAuthorityCsrResponse response = certificateAuthorityServiceClient.FetchCertificateAuthorityCsr(name);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
FetchCertificateAuthorityCsrRequest request = new FetchCertificateAuthorityCsrRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
};
// Make the request
FetchCertificateAuthorityCsrResponse response = certificateAuthorityServiceClient.FetchCertificateAuthorityCsr(request);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
FetchCertificateAuthorityCsrResponse response = certificateAuthorityServiceClient.FetchCertificateAuthorityCsr(name);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
FetchCertificateAuthorityCsrResponse response = await certificateAuthorityServiceClient.FetchCertificateAuthorityCsrAsync(name);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CertificateAuthorityName name = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]");
// Make the request
FetchCertificateAuthorityCsrResponse response = await certificateAuthorityServiceClient.FetchCertificateAuthorityCsrAsync(name);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
FetchCertificateAuthorityCsrRequest request = new FetchCertificateAuthorityCsrRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
};
// Make the request
FetchCertificateAuthorityCsrResponse response = await certificateAuthorityServiceClient.FetchCertificateAuthorityCsrAsync(request);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
FetchCertificateAuthorityCsrRequest request = new FetchCertificateAuthorityCsrRequest
{
    CertificateAuthorityName = CertificateAuthorityName.FromProjectLocationCaPoolCertificateAuthority("[PROJECT]", "[LOCATION]", "[CA_POOL]", "[CERTIFICATE_AUTHORITY]"),
};
// Make the request
FetchCertificateAuthorityCsrResponse response = await certificateAuthorityServiceClient.FetchCertificateAuthorityCsrAsync(request);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
FetchCertificateAuthorityCsrResponse response = await certificateAuthorityServiceClient.FetchCertificateAuthorityCsrAsync(name);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]/certificateAuthorities/[CERTIFICATE_AUTHORITY]";
// Make the request
FetchCertificateAuthorityCsrResponse response = await certificateAuthorityServiceClient.FetchCertificateAuthorityCsrAsync(name);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
CaPoolName name = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
// Make the request
CaPool response = certificateAuthorityServiceClient.GetCaPool(name);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
GetCaPoolRequest request = new GetCaPoolRequest
{
    CaPoolName = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]"),
};
// Make the request
CaPool response = certificateAuthorityServiceClient.GetCaPool(request);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = CertificateAuthorityServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/caPools/[CA_POOL]";
// Make the request
CaPool response = certificateAuthorityServiceClient.GetCaPool(name);

// Create client
CertificateAuthorityServiceClient certificateAuthorityServiceClient = await CertificateAuthorityServiceClient.CreateAsync();
// Initialize request argument(s)
CaPoolName name = CaPoolName.FromProjectLocationCaPool("[PROJECT]", "[LOCATION]", "[CA_POOL]");
// Make the request
CaPool response = await certificateAuthorityServiceClient.GetCaPoolAsync(name);