Class DomainsClient (1.0.0-beta04)

public abstract class DomainsClient

Namespace

Assembly

Google.Cloud.Domains.V1Beta1.dll

Remarks

Properties

ConfigureContactSettingsOperationsClient

public virtual OperationsClient ConfigureContactSettingsOperationsClient { get; }

ConfigureDnsSettingsOperationsClient

public virtual OperationsClient ConfigureDnsSettingsOperationsClient { get; }

ConfigureManagementSettingsOperationsClient

public virtual OperationsClient ConfigureManagementSettingsOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteRegistrationOperationsClient

public virtual OperationsClient DeleteRegistrationOperationsClient { get; }

ExportRegistrationOperationsClient

public virtual OperationsClient ExportRegistrationOperationsClient { get; }

GrpcClient

public virtual Domains.DomainsClient GrpcClient { get; }

RegisterDomainOperationsClient

public virtual OperationsClient RegisterDomainOperationsClient { get; }

TransferDomainOperationsClient

public virtual OperationsClient TransferDomainOperationsClient { get; }

UpdateRegistrationOperationsClient

public virtual OperationsClient UpdateRegistrationOperationsClient { get; }

Methods

ConfigureContactSettings(ConfigureContactSettingsRequest, CallSettings)

public virtual Operation<Registration, OperationMetadata> ConfigureContactSettings(ConfigureContactSettingsRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
ConfigureContactSettingsRequest request = new ConfigureContactSettingsRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
    ContactSettings = new ContactSettings(),
    UpdateMask = new FieldMask(),
    ContactNotices =
    {
        ContactNotice.Unspecified,
    },
    ValidateOnly = false,
};
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ConfigureContactSettings(request);

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

ConfigureContactSettings(RegistrationName, ContactSettings, FieldMask, CallSettings)

public virtual Operation<Registration, OperationMetadata> ConfigureContactSettings(RegistrationName registration, ContactSettings contactSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
ContactSettings contactSettings = new ContactSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ConfigureContactSettings(registration, contactSettings, updateMask);

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

ConfigureContactSettings(String, ContactSettings, FieldMask, CallSettings)

public virtual Operation<Registration, OperationMetadata> ConfigureContactSettings(string registration, ContactSettings contactSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
ContactSettings contactSettings = new ContactSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ConfigureContactSettings(registration, contactSettings, updateMask);

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

ConfigureContactSettingsAsync(ConfigureContactSettingsRequest, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureContactSettingsAsync(ConfigureContactSettingsRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
ConfigureContactSettingsRequest request = new ConfigureContactSettingsRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
    ContactSettings = new ContactSettings(),
    UpdateMask = new FieldMask(),
    ContactNotices =
    {
        ContactNotice.Unspecified,
    },
    ValidateOnly = false,
};
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureContactSettingsAsync(request);

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

ConfigureContactSettingsAsync(ConfigureContactSettingsRequest, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureContactSettingsAsync(ConfigureContactSettingsRequest request, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
ConfigureContactSettingsRequest request = new ConfigureContactSettingsRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
    ContactSettings = new ContactSettings(),
    UpdateMask = new FieldMask(),
    ContactNotices =
    {
        ContactNotice.Unspecified,
    },
    ValidateOnly = false,
};
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureContactSettingsAsync(request);

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

ConfigureContactSettingsAsync(RegistrationName, ContactSettings, FieldMask, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureContactSettingsAsync(RegistrationName registration, ContactSettings contactSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
ContactSettings contactSettings = new ContactSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureContactSettingsAsync(registration, contactSettings, updateMask);

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

ConfigureContactSettingsAsync(RegistrationName, ContactSettings, FieldMask, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureContactSettingsAsync(RegistrationName registration, ContactSettings contactSettings, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
ContactSettings contactSettings = new ContactSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureContactSettingsAsync(registration, contactSettings, updateMask);

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

ConfigureContactSettingsAsync(String, ContactSettings, FieldMask, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureContactSettingsAsync(string registration, ContactSettings contactSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
ContactSettings contactSettings = new ContactSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureContactSettingsAsync(registration, contactSettings, updateMask);

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

ConfigureContactSettingsAsync(String, ContactSettings, FieldMask, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureContactSettingsAsync(string registration, ContactSettings contactSettings, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
ContactSettings contactSettings = new ContactSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureContactSettingsAsync(registration, contactSettings, updateMask);

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

ConfigureDnsSettings(ConfigureDnsSettingsRequest, CallSettings)

public virtual Operation<Registration, OperationMetadata> ConfigureDnsSettings(ConfigureDnsSettingsRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
ConfigureDnsSettingsRequest request = new ConfigureDnsSettingsRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
    DnsSettings = new DnsSettings(),
    UpdateMask = new FieldMask(),
    ValidateOnly = false,
};
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ConfigureDnsSettings(request);

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

ConfigureDnsSettings(RegistrationName, DnsSettings, FieldMask, CallSettings)

public virtual Operation<Registration, OperationMetadata> ConfigureDnsSettings(RegistrationName registration, DnsSettings dnsSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
DnsSettings dnsSettings = new DnsSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ConfigureDnsSettings(registration, dnsSettings, updateMask);

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

ConfigureDnsSettings(String, DnsSettings, FieldMask, CallSettings)

public virtual Operation<Registration, OperationMetadata> ConfigureDnsSettings(string registration, DnsSettings dnsSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
DnsSettings dnsSettings = new DnsSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ConfigureDnsSettings(registration, dnsSettings, updateMask);

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

ConfigureDnsSettingsAsync(ConfigureDnsSettingsRequest, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureDnsSettingsAsync(ConfigureDnsSettingsRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
ConfigureDnsSettingsRequest request = new ConfigureDnsSettingsRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
    DnsSettings = new DnsSettings(),
    UpdateMask = new FieldMask(),
    ValidateOnly = false,
};
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureDnsSettingsAsync(request);

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

ConfigureDnsSettingsAsync(ConfigureDnsSettingsRequest, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureDnsSettingsAsync(ConfigureDnsSettingsRequest request, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
ConfigureDnsSettingsRequest request = new ConfigureDnsSettingsRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
    DnsSettings = new DnsSettings(),
    UpdateMask = new FieldMask(),
    ValidateOnly = false,
};
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureDnsSettingsAsync(request);

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

ConfigureDnsSettingsAsync(RegistrationName, DnsSettings, FieldMask, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureDnsSettingsAsync(RegistrationName registration, DnsSettings dnsSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
DnsSettings dnsSettings = new DnsSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureDnsSettingsAsync(registration, dnsSettings, updateMask);

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

ConfigureDnsSettingsAsync(RegistrationName, DnsSettings, FieldMask, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureDnsSettingsAsync(RegistrationName registration, DnsSettings dnsSettings, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
DnsSettings dnsSettings = new DnsSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureDnsSettingsAsync(registration, dnsSettings, updateMask);

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

ConfigureDnsSettingsAsync(String, DnsSettings, FieldMask, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureDnsSettingsAsync(string registration, DnsSettings dnsSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
DnsSettings dnsSettings = new DnsSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureDnsSettingsAsync(registration, dnsSettings, updateMask);

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

ConfigureDnsSettingsAsync(String, DnsSettings, FieldMask, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureDnsSettingsAsync(string registration, DnsSettings dnsSettings, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
DnsSettings dnsSettings = new DnsSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureDnsSettingsAsync(registration, dnsSettings, updateMask);

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

ConfigureManagementSettings(ConfigureManagementSettingsRequest, CallSettings)

public virtual Operation<Registration, OperationMetadata> ConfigureManagementSettings(ConfigureManagementSettingsRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
ConfigureManagementSettingsRequest request = new ConfigureManagementSettingsRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
    ManagementSettings = new ManagementSettings(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ConfigureManagementSettings(request);

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

ConfigureManagementSettings(RegistrationName, ManagementSettings, FieldMask, CallSettings)

public virtual Operation<Registration, OperationMetadata> ConfigureManagementSettings(RegistrationName registration, ManagementSettings managementSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
ManagementSettings managementSettings = new ManagementSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ConfigureManagementSettings(registration, managementSettings, updateMask);

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

ConfigureManagementSettings(String, ManagementSettings, FieldMask, CallSettings)

public virtual Operation<Registration, OperationMetadata> ConfigureManagementSettings(string registration, ManagementSettings managementSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
ManagementSettings managementSettings = new ManagementSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ConfigureManagementSettings(registration, managementSettings, updateMask);

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

ConfigureManagementSettingsAsync(ConfigureManagementSettingsRequest, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureManagementSettingsAsync(ConfigureManagementSettingsRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
ConfigureManagementSettingsRequest request = new ConfigureManagementSettingsRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
    ManagementSettings = new ManagementSettings(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureManagementSettingsAsync(request);

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

ConfigureManagementSettingsAsync(ConfigureManagementSettingsRequest, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureManagementSettingsAsync(ConfigureManagementSettingsRequest request, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
ConfigureManagementSettingsRequest request = new ConfigureManagementSettingsRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
    ManagementSettings = new ManagementSettings(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureManagementSettingsAsync(request);

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

ConfigureManagementSettingsAsync(RegistrationName, ManagementSettings, FieldMask, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureManagementSettingsAsync(RegistrationName registration, ManagementSettings managementSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
ManagementSettings managementSettings = new ManagementSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureManagementSettingsAsync(registration, managementSettings, updateMask);

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

ConfigureManagementSettingsAsync(RegistrationName, ManagementSettings, FieldMask, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureManagementSettingsAsync(RegistrationName registration, ManagementSettings managementSettings, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
ManagementSettings managementSettings = new ManagementSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureManagementSettingsAsync(registration, managementSettings, updateMask);

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

ConfigureManagementSettingsAsync(String, ManagementSettings, FieldMask, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureManagementSettingsAsync(string registration, ManagementSettings managementSettings, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
ManagementSettings managementSettings = new ManagementSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureManagementSettingsAsync(registration, managementSettings, updateMask);

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

ConfigureManagementSettingsAsync(String, ManagementSettings, FieldMask, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ConfigureManagementSettingsAsync(string registration, ManagementSettings managementSettings, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
ManagementSettings managementSettings = new ManagementSettings();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ConfigureManagementSettingsAsync(registration, managementSettings, updateMask);

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

Create()

public static DomainsClient Create()

CreateAsync(CancellationToken)

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

DeleteRegistration(DeleteRegistrationRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteRegistration(DeleteRegistrationRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
DeleteRegistrationRequest request = new DeleteRegistrationRequest
{
    RegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = domainsClient.DeleteRegistration(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 = domainsClient.PollOnceDeleteRegistration(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;
}

DeleteRegistration(RegistrationName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteRegistration(RegistrationName name, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RegistrationName name = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
Operation<Empty, OperationMetadata> response = domainsClient.DeleteRegistration(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 = domainsClient.PollOnceDeleteRegistration(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;
}

DeleteRegistration(String, CallSettings)

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

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
Operation<Empty, OperationMetadata> response = domainsClient.DeleteRegistration(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 = domainsClient.PollOnceDeleteRegistration(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;
}

DeleteRegistrationAsync(DeleteRegistrationRequest, CallSettings)

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

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
DeleteRegistrationRequest request = new DeleteRegistrationRequest
{
    RegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await domainsClient.DeleteRegistrationAsync(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 domainsClient.PollOnceDeleteRegistrationAsync(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;
}

DeleteRegistrationAsync(DeleteRegistrationRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRegistrationAsync(DeleteRegistrationRequest request, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
DeleteRegistrationRequest request = new DeleteRegistrationRequest
{
    RegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await domainsClient.DeleteRegistrationAsync(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 domainsClient.PollOnceDeleteRegistrationAsync(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;
}

DeleteRegistrationAsync(RegistrationName, CallSettings)

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

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName name = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
Operation<Empty, OperationMetadata> response = await domainsClient.DeleteRegistrationAsync(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 domainsClient.PollOnceDeleteRegistrationAsync(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;
}

DeleteRegistrationAsync(RegistrationName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRegistrationAsync(RegistrationName name, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName name = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
Operation<Empty, OperationMetadata> response = await domainsClient.DeleteRegistrationAsync(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 domainsClient.PollOnceDeleteRegistrationAsync(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;
}

DeleteRegistrationAsync(String, CallSettings)

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

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
Operation<Empty, OperationMetadata> response = await domainsClient.DeleteRegistrationAsync(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 domainsClient.PollOnceDeleteRegistrationAsync(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;
}

DeleteRegistrationAsync(String, CancellationToken)

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

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
Operation<Empty, OperationMetadata> response = await domainsClient.DeleteRegistrationAsync(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 domainsClient.PollOnceDeleteRegistrationAsync(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;
}

ExportRegistration(ExportRegistrationRequest, CallSettings)

public virtual Operation<Registration, OperationMetadata> ExportRegistration(ExportRegistrationRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
ExportRegistrationRequest request = new ExportRegistrationRequest
{
    RegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ExportRegistration(request);

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

ExportRegistration(RegistrationName, CallSettings)

public virtual Operation<Registration, OperationMetadata> ExportRegistration(RegistrationName name, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RegistrationName name = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ExportRegistration(name);

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

ExportRegistration(String, CallSettings)

public virtual Operation<Registration, OperationMetadata> ExportRegistration(string name, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.ExportRegistration(name);

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

ExportRegistrationAsync(ExportRegistrationRequest, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> ExportRegistrationAsync(ExportRegistrationRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
ExportRegistrationRequest request = new ExportRegistrationRequest
{
    RegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ExportRegistrationAsync(request);

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

ExportRegistrationAsync(ExportRegistrationRequest, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ExportRegistrationAsync(ExportRegistrationRequest request, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
ExportRegistrationRequest request = new ExportRegistrationRequest
{
    RegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ExportRegistrationAsync(request);

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

ExportRegistrationAsync(RegistrationName, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> ExportRegistrationAsync(RegistrationName name, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName name = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ExportRegistrationAsync(name);

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

ExportRegistrationAsync(RegistrationName, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ExportRegistrationAsync(RegistrationName name, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName name = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ExportRegistrationAsync(name);

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

ExportRegistrationAsync(String, CallSettings)

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

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ExportRegistrationAsync(name);

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

ExportRegistrationAsync(String, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> ExportRegistrationAsync(string name, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.ExportRegistrationAsync(name);

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

GetRegistration(GetRegistrationRequest, CallSettings)

public virtual Registration GetRegistration(GetRegistrationRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
GetRegistrationRequest request = new GetRegistrationRequest
{
    RegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
Registration response = domainsClient.GetRegistration(request);

GetRegistration(RegistrationName, CallSettings)

public virtual Registration GetRegistration(RegistrationName name, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RegistrationName name = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
Registration response = domainsClient.GetRegistration(name);

GetRegistration(String, CallSettings)

public virtual Registration GetRegistration(string name, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
Registration response = domainsClient.GetRegistration(name);

GetRegistrationAsync(GetRegistrationRequest, CallSettings)

public virtual Task<Registration> GetRegistrationAsync(GetRegistrationRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
GetRegistrationRequest request = new GetRegistrationRequest
{
    RegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
Registration response = await domainsClient.GetRegistrationAsync(request);

GetRegistrationAsync(GetRegistrationRequest, CancellationToken)

public virtual Task<Registration> GetRegistrationAsync(GetRegistrationRequest request, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
GetRegistrationRequest request = new GetRegistrationRequest
{
    RegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
Registration response = await domainsClient.GetRegistrationAsync(request);

GetRegistrationAsync(RegistrationName, CallSettings)

public virtual Task<Registration> GetRegistrationAsync(RegistrationName name, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName name = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
Registration response = await domainsClient.GetRegistrationAsync(name);

GetRegistrationAsync(RegistrationName, CancellationToken)

public virtual Task<Registration> GetRegistrationAsync(RegistrationName name, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName name = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
Registration response = await domainsClient.GetRegistrationAsync(name);

GetRegistrationAsync(String, CallSettings)

public virtual Task<Registration> GetRegistrationAsync(string name, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
Registration response = await domainsClient.GetRegistrationAsync(name);

GetRegistrationAsync(String, CancellationToken)

public virtual Task<Registration> GetRegistrationAsync(string name, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
Registration response = await domainsClient.GetRegistrationAsync(name);

ListRegistrations(LocationName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListRegistrationsResponse, Registration> ListRegistrations(LocationName parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListRegistrationsResponse, Registration> response = domainsClient.ListRegistrations(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Registration item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListRegistrationsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Registration item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Registration> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Registration item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListRegistrations(ListRegistrationsRequest, CallSettings)

public virtual PagedEnumerable<ListRegistrationsResponse, Registration> ListRegistrations(ListRegistrationsRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
ListRegistrationsRequest request = new ListRegistrationsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
};
// Make the request
PagedEnumerable<ListRegistrationsResponse, Registration> response = domainsClient.ListRegistrations(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Registration item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListRegistrationsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Registration item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Registration> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Registration item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListRegistrations(String, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListRegistrationsResponse, Registration> ListRegistrations(string parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListRegistrationsResponse, Registration> response = domainsClient.ListRegistrations(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Registration item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListRegistrationsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Registration item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Registration> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Registration item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListRegistrationsAsync(LocationName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListRegistrationsResponse, Registration> ListRegistrationsAsync(LocationName parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListRegistrationsResponse, Registration> response = domainsClient.ListRegistrationsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Registration item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListRegistrationsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Registration item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Registration> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Registration item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListRegistrationsAsync(ListRegistrationsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListRegistrationsResponse, Registration> ListRegistrationsAsync(ListRegistrationsRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
ListRegistrationsRequest request = new ListRegistrationsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListRegistrationsResponse, Registration> response = domainsClient.ListRegistrationsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Registration item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListRegistrationsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Registration item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Registration> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Registration item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListRegistrationsAsync(String, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListRegistrationsResponse, Registration> ListRegistrationsAsync(string parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListRegistrationsResponse, Registration> response = domainsClient.ListRegistrationsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Registration item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListRegistrationsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Registration item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Registration> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Registration item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

PollOnceConfigureContactSettings(String, CallSettings)

public virtual Operation<Registration, OperationMetadata> PollOnceConfigureContactSettings(string operationName, CallSettings callSettings = null)

PollOnceConfigureContactSettingsAsync(String, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> PollOnceConfigureContactSettingsAsync(string operationName, CallSettings callSettings = null)

PollOnceConfigureDnsSettings(String, CallSettings)

public virtual Operation<Registration, OperationMetadata> PollOnceConfigureDnsSettings(string operationName, CallSettings callSettings = null)

PollOnceConfigureDnsSettingsAsync(String, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> PollOnceConfigureDnsSettingsAsync(string operationName, CallSettings callSettings = null)

PollOnceConfigureManagementSettings(String, CallSettings)

public virtual Operation<Registration, OperationMetadata> PollOnceConfigureManagementSettings(string operationName, CallSettings callSettings = null)

PollOnceConfigureManagementSettingsAsync(String, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> PollOnceConfigureManagementSettingsAsync(string operationName, CallSettings callSettings = null)

PollOnceDeleteRegistration(String, CallSettings)

public virtual Operation<Empty, OperationMetadata> PollOnceDeleteRegistration(string operationName, CallSettings callSettings = null)

PollOnceDeleteRegistrationAsync(String, CallSettings)

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

PollOnceExportRegistration(String, CallSettings)

public virtual Operation<Registration, OperationMetadata> PollOnceExportRegistration(string operationName, CallSettings callSettings = null)

PollOnceExportRegistrationAsync(String, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> PollOnceExportRegistrationAsync(string operationName, CallSettings callSettings = null)

PollOnceRegisterDomain(String, CallSettings)

public virtual Operation<Registration, OperationMetadata> PollOnceRegisterDomain(string operationName, CallSettings callSettings = null)

PollOnceRegisterDomainAsync(String, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> PollOnceRegisterDomainAsync(string operationName, CallSettings callSettings = null)

PollOnceTransferDomain(String, CallSettings)

public virtual Operation<Registration, OperationMetadata> PollOnceTransferDomain(string operationName, CallSettings callSettings = null)

PollOnceTransferDomainAsync(String, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> PollOnceTransferDomainAsync(string operationName, CallSettings callSettings = null)

PollOnceUpdateRegistration(String, CallSettings)

public virtual Operation<Registration, OperationMetadata> PollOnceUpdateRegistration(string operationName, CallSettings callSettings = null)

PollOnceUpdateRegistrationAsync(String, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> PollOnceUpdateRegistrationAsync(string operationName, CallSettings callSettings = null)

RegisterDomain(LocationName, Registration, Money, CallSettings)

public virtual Operation<Registration, OperationMetadata> RegisterDomain(LocationName parent, Registration registration, Money yearlyPrice, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Registration registration = new Registration();
Money yearlyPrice = new Money();
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.RegisterDomain(parent, registration, yearlyPrice);

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

RegisterDomain(RegisterDomainRequest, CallSettings)

public virtual Operation<Registration, OperationMetadata> RegisterDomain(RegisterDomainRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RegisterDomainRequest request = new RegisterDomainRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Registration = new Registration(),
    DomainNotices =
    {
        DomainNotice.Unspecified,
    },
    ContactNotices =
    {
        ContactNotice.Unspecified,
    },
    YearlyPrice = new Money(),
    ValidateOnly = false,
};
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.RegisterDomain(request);

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

RegisterDomain(String, Registration, Money, CallSettings)

public virtual Operation<Registration, OperationMetadata> RegisterDomain(string parent, Registration registration, Money yearlyPrice, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Registration registration = new Registration();
Money yearlyPrice = new Money();
// Make the request
Operation<Registration, OperationMetadata> response = domainsClient.RegisterDomain(parent, registration, yearlyPrice);

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

RegisterDomainAsync(LocationName, Registration, Money, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> RegisterDomainAsync(LocationName parent, Registration registration, Money yearlyPrice, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Registration registration = new Registration();
Money yearlyPrice = new Money();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.RegisterDomainAsync(parent, registration, yearlyPrice);

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

RegisterDomainAsync(LocationName, Registration, Money, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> RegisterDomainAsync(LocationName parent, Registration registration, Money yearlyPrice, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Registration registration = new Registration();
Money yearlyPrice = new Money();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.RegisterDomainAsync(parent, registration, yearlyPrice);

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

RegisterDomainAsync(RegisterDomainRequest, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> RegisterDomainAsync(RegisterDomainRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegisterDomainRequest request = new RegisterDomainRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Registration = new Registration(),
    DomainNotices =
    {
        DomainNotice.Unspecified,
    },
    ContactNotices =
    {
        ContactNotice.Unspecified,
    },
    YearlyPrice = new Money(),
    ValidateOnly = false,
};
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.RegisterDomainAsync(request);

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

RegisterDomainAsync(RegisterDomainRequest, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> RegisterDomainAsync(RegisterDomainRequest request, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegisterDomainRequest request = new RegisterDomainRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Registration = new Registration(),
    DomainNotices =
    {
        DomainNotice.Unspecified,
    },
    ContactNotices =
    {
        ContactNotice.Unspecified,
    },
    YearlyPrice = new Money(),
    ValidateOnly = false,
};
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.RegisterDomainAsync(request);

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

RegisterDomainAsync(String, Registration, Money, CallSettings)

public virtual Task<Operation<Registration, OperationMetadata>> RegisterDomainAsync(string parent, Registration registration, Money yearlyPrice, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Registration registration = new Registration();
Money yearlyPrice = new Money();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.RegisterDomainAsync(parent, registration, yearlyPrice);

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

RegisterDomainAsync(String, Registration, Money, CancellationToken)

public virtual Task<Operation<Registration, OperationMetadata>> RegisterDomainAsync(string parent, Registration registration, Money yearlyPrice, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Registration registration = new Registration();
Money yearlyPrice = new Money();
// Make the request
Operation<Registration, OperationMetadata> response = await domainsClient.RegisterDomainAsync(parent, registration, yearlyPrice);

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

ResetAuthorizationCode(RegistrationName, CallSettings)

public virtual AuthorizationCode ResetAuthorizationCode(RegistrationName registration, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
AuthorizationCode response = domainsClient.ResetAuthorizationCode(registration);

ResetAuthorizationCode(ResetAuthorizationCodeRequest, CallSettings)

public virtual AuthorizationCode ResetAuthorizationCode(ResetAuthorizationCodeRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
ResetAuthorizationCodeRequest request = new ResetAuthorizationCodeRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
AuthorizationCode response = domainsClient.ResetAuthorizationCode(request);

ResetAuthorizationCode(String, CallSettings)

public virtual AuthorizationCode ResetAuthorizationCode(string registration, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
AuthorizationCode response = domainsClient.ResetAuthorizationCode(registration);

ResetAuthorizationCodeAsync(RegistrationName, CallSettings)

public virtual Task<AuthorizationCode> ResetAuthorizationCodeAsync(RegistrationName registration, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
AuthorizationCode response = await domainsClient.ResetAuthorizationCodeAsync(registration);

ResetAuthorizationCodeAsync(RegistrationName, CancellationToken)

public virtual Task<AuthorizationCode> ResetAuthorizationCodeAsync(RegistrationName registration, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
AuthorizationCode response = await domainsClient.ResetAuthorizationCodeAsync(registration);

ResetAuthorizationCodeAsync(ResetAuthorizationCodeRequest, CallSettings)

public virtual Task<AuthorizationCode> ResetAuthorizationCodeAsync(ResetAuthorizationCodeRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
ResetAuthorizationCodeRequest request = new ResetAuthorizationCodeRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
AuthorizationCode response = await domainsClient.ResetAuthorizationCodeAsync(request);

ResetAuthorizationCodeAsync(ResetAuthorizationCodeRequest, CancellationToken)

public virtual Task<AuthorizationCode> ResetAuthorizationCodeAsync(ResetAuthorizationCodeRequest request, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
ResetAuthorizationCodeRequest request = new ResetAuthorizationCodeRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
AuthorizationCode response = await domainsClient.ResetAuthorizationCodeAsync(request);

ResetAuthorizationCodeAsync(String, CallSettings)

public virtual Task<AuthorizationCode> ResetAuthorizationCodeAsync(string registration, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
AuthorizationCode response = await domainsClient.ResetAuthorizationCodeAsync(registration);

ResetAuthorizationCodeAsync(String, CancellationToken)

public virtual Task<AuthorizationCode> ResetAuthorizationCodeAsync(string registration, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
AuthorizationCode response = await domainsClient.ResetAuthorizationCodeAsync(registration);

RetrieveAuthorizationCode(RegistrationName, CallSettings)

public virtual AuthorizationCode RetrieveAuthorizationCode(RegistrationName registration, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
AuthorizationCode response = domainsClient.RetrieveAuthorizationCode(registration);

RetrieveAuthorizationCode(RetrieveAuthorizationCodeRequest, CallSettings)

public virtual AuthorizationCode RetrieveAuthorizationCode(RetrieveAuthorizationCodeRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RetrieveAuthorizationCodeRequest request = new RetrieveAuthorizationCodeRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
AuthorizationCode response = domainsClient.RetrieveAuthorizationCode(request);

RetrieveAuthorizationCode(String, CallSettings)

public virtual AuthorizationCode RetrieveAuthorizationCode(string registration, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
AuthorizationCode response = domainsClient.RetrieveAuthorizationCode(registration);

RetrieveAuthorizationCodeAsync(RegistrationName, CallSettings)

public virtual Task<AuthorizationCode> RetrieveAuthorizationCodeAsync(RegistrationName registration, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
AuthorizationCode response = await domainsClient.RetrieveAuthorizationCodeAsync(registration);

RetrieveAuthorizationCodeAsync(RegistrationName, CancellationToken)

public virtual Task<AuthorizationCode> RetrieveAuthorizationCodeAsync(RegistrationName registration, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RegistrationName registration = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
// Make the request
AuthorizationCode response = await domainsClient.RetrieveAuthorizationCodeAsync(registration);

RetrieveAuthorizationCodeAsync(RetrieveAuthorizationCodeRequest, CallSettings)

public virtual Task<AuthorizationCode> RetrieveAuthorizationCodeAsync(RetrieveAuthorizationCodeRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RetrieveAuthorizationCodeRequest request = new RetrieveAuthorizationCodeRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
AuthorizationCode response = await domainsClient.RetrieveAuthorizationCodeAsync(request);

RetrieveAuthorizationCodeAsync(RetrieveAuthorizationCodeRequest, CancellationToken)

public virtual Task<AuthorizationCode> RetrieveAuthorizationCodeAsync(RetrieveAuthorizationCodeRequest request, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RetrieveAuthorizationCodeRequest request = new RetrieveAuthorizationCodeRequest
{
    RegistrationAsRegistrationName = RegistrationName.FromProjectLocationRegistration("[PROJECT]", "[LOCATION]", "[REGISTRATION]"),
};
// Make the request
AuthorizationCode response = await domainsClient.RetrieveAuthorizationCodeAsync(request);

RetrieveAuthorizationCodeAsync(String, CallSettings)

public virtual Task<AuthorizationCode> RetrieveAuthorizationCodeAsync(string registration, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
AuthorizationCode response = await domainsClient.RetrieveAuthorizationCodeAsync(registration);

RetrieveAuthorizationCodeAsync(String, CancellationToken)

public virtual Task<AuthorizationCode> RetrieveAuthorizationCodeAsync(string registration, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string registration = "projects/[PROJECT]/locations/[LOCATION]/registrations/[REGISTRATION]";
// Make the request
AuthorizationCode response = await domainsClient.RetrieveAuthorizationCodeAsync(registration);

RetrieveRegisterParameters(LocationName, String, CallSettings)

public virtual RetrieveRegisterParametersResponse RetrieveRegisterParameters(LocationName location, string domainName, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
LocationName location = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string domainName = "";
// Make the request
RetrieveRegisterParametersResponse response = domainsClient.RetrieveRegisterParameters(location, domainName);

RetrieveRegisterParameters(RetrieveRegisterParametersRequest, CallSettings)

public virtual RetrieveRegisterParametersResponse RetrieveRegisterParameters(RetrieveRegisterParametersRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RetrieveRegisterParametersRequest request = new RetrieveRegisterParametersRequest
{
    DomainName = "",
    LocationAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
RetrieveRegisterParametersResponse response = domainsClient.RetrieveRegisterParameters(request);

RetrieveRegisterParameters(String, String, CallSettings)

public virtual RetrieveRegisterParametersResponse RetrieveRegisterParameters(string location, string domainName, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
string location = "projects/[PROJECT]/locations/[LOCATION]";
string domainName = "";
// Make the request
RetrieveRegisterParametersResponse response = domainsClient.RetrieveRegisterParameters(location, domainName);

RetrieveRegisterParametersAsync(LocationName, String, CallSettings)

public virtual Task<RetrieveRegisterParametersResponse> RetrieveRegisterParametersAsync(LocationName location, string domainName, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
LocationName location = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string domainName = "";
// Make the request
RetrieveRegisterParametersResponse response = await domainsClient.RetrieveRegisterParametersAsync(location, domainName);

RetrieveRegisterParametersAsync(LocationName, String, CancellationToken)

public virtual Task<RetrieveRegisterParametersResponse> RetrieveRegisterParametersAsync(LocationName location, string domainName, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
LocationName location = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string domainName = "";
// Make the request
RetrieveRegisterParametersResponse response = await domainsClient.RetrieveRegisterParametersAsync(location, domainName);

RetrieveRegisterParametersAsync(RetrieveRegisterParametersRequest, CallSettings)

public virtual Task<RetrieveRegisterParametersResponse> RetrieveRegisterParametersAsync(RetrieveRegisterParametersRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RetrieveRegisterParametersRequest request = new RetrieveRegisterParametersRequest
{
    DomainName = "",
    LocationAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
RetrieveRegisterParametersResponse response = await domainsClient.RetrieveRegisterParametersAsync(request);

RetrieveRegisterParametersAsync(RetrieveRegisterParametersRequest, CancellationToken)

public virtual Task<RetrieveRegisterParametersResponse> RetrieveRegisterParametersAsync(RetrieveRegisterParametersRequest request, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
RetrieveRegisterParametersRequest request = new RetrieveRegisterParametersRequest
{
    DomainName = "",
    LocationAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
RetrieveRegisterParametersResponse response = await domainsClient.RetrieveRegisterParametersAsync(request);

RetrieveRegisterParametersAsync(String, String, CallSettings)

public virtual Task<RetrieveRegisterParametersResponse> RetrieveRegisterParametersAsync(string location, string domainName, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string location = "projects/[PROJECT]/locations/[LOCATION]";
string domainName = "";
// Make the request
RetrieveRegisterParametersResponse response = await domainsClient.RetrieveRegisterParametersAsync(location, domainName);

RetrieveRegisterParametersAsync(String, String, CancellationToken)

public virtual Task<RetrieveRegisterParametersResponse> RetrieveRegisterParametersAsync(string location, string domainName, CancellationToken cancellationToken)

// Create client
DomainsClient domainsClient = await DomainsClient.CreateAsync();
// Initialize request argument(s)
string location = "projects/[PROJECT]/locations/[LOCATION]";
string domainName = "";
// Make the request
RetrieveRegisterParametersResponse response = await domainsClient.RetrieveRegisterParametersAsync(location, domainName);

RetrieveTransferParameters(LocationName, String, CallSettings)

public virtual RetrieveTransferParametersResponse RetrieveTransferParameters(LocationName location, string domainName, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
LocationName location = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string domainName = "";
// Make the request
RetrieveTransferParametersResponse response = domainsClient.RetrieveTransferParameters(location, domainName);

RetrieveTransferParameters(RetrieveTransferParametersRequest, CallSettings)

public virtual RetrieveTransferParametersResponse RetrieveTransferParameters(RetrieveTransferParametersRequest request, CallSettings callSettings = null)

// Create client
DomainsClient domainsClient = DomainsClient.Create();
// Initialize request argument(s)
RetrieveTransferParametersRequest request = new RetrieveTransferParametersRequest
{
    DomainName = "",
    LocationAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
RetrieveTransferParametersResponse response = domainsClient.RetrieveTransferParameters(request);

RetrieveTransferParameters(String, String, CallSettings)

public virtual RetrieveTransferParametersResponse RetrieveTransferParameters(string location, string domainName, CallSettings callSettings = null)