Class DomainsClient

  • All Implemented Interfaces:
    com.google.api.gax.core.BackgroundResource, AutoCloseable

    @BetaApi
    @Generated("by gapic-generator-java")
    public class DomainsClient
    extends Object
    implements com.google.api.gax.core.BackgroundResource
    Service Description: The Cloud Domains API enables management and configuration of domain names.

    This class provides the ability to make remote calls to the backing service through method calls that map to API methods. Sample code to get started:

    
     // This snippet has been automatically generated and should be regarded as a code template only.
     // It will require modifications to work:
     // - It may require correct/in-range values for request initialization.
     // - It may require specifying regional endpoints when creating the service client as shown in
     // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
     try (DomainsClient domainsClient = DomainsClient.create()) {
       LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
       String query = "query107944136";
       SearchDomainsResponse response = domainsClient.searchDomains(location, query);
     }
     

    Note: close() needs to be called on the DomainsClient object to clean up resources such as threads. In the example above, try-with-resources is used, which automatically calls close().

    The surface of this class includes several types of Java methods for each of the API's methods:

    1. A "flattened" method. With this type of method, the fields of the request type have been converted into function parameters. It may be the case that not all fields are available as parameters, and not every API method will have a flattened method entry point.
    2. A "request object" method. This type of method only takes one parameter, a request object, which must be constructed before the call. Not every API method will have a request object method.
    3. A "callable" method. This type of method takes no parameters and returns an immutable API callable object, which can be used to initiate calls to the service.

    See the individual methods for example code.

    Many parameters require resource names to be formatted in a particular way. To assist with these names, this class includes a format method for each type of name, and additionally a parse method to extract the individual identifiers contained within names that are returned.

    This class can be customized by passing in a custom instance of DomainsSettings to create(). For example:

    To customize credentials:

    
     // This snippet has been automatically generated and should be regarded as a code template only.
     // It will require modifications to work:
     // - It may require correct/in-range values for request initialization.
     // - It may require specifying regional endpoints when creating the service client as shown in
     // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
     DomainsSettings domainsSettings =
         DomainsSettings.newBuilder()
             .setCredentialsProvider(FixedCredentialsProvider.create(myCredentials))
             .build();
     DomainsClient domainsClient = DomainsClient.create(domainsSettings);
     

    To customize the endpoint:

    
     // This snippet has been automatically generated and should be regarded as a code template only.
     // It will require modifications to work:
     // - It may require correct/in-range values for request initialization.
     // - It may require specifying regional endpoints when creating the service client as shown in
     // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
     DomainsSettings domainsSettings = DomainsSettings.newBuilder().setEndpoint(myEndpoint).build();
     DomainsClient domainsClient = DomainsClient.create(domainsSettings);
     

    To use REST (HTTP1.1/JSON) transport (instead of gRPC) for sending and receiving requests over the wire:

    
     // This snippet has been automatically generated and should be regarded as a code template only.
     // It will require modifications to work:
     // - It may require correct/in-range values for request initialization.
     // - It may require specifying regional endpoints when creating the service client as shown in
     // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
     DomainsSettings domainsSettings = DomainsSettings.newHttpJsonBuilder().build();
     DomainsClient domainsClient = DomainsClient.create(domainsSettings);
     

    Please refer to the GitHub repository's samples for more quickstart code snippets.

    • Constructor Detail

      • DomainsClient

        protected DomainsClient​(DomainsSettings settings)
                         throws IOException
        Constructs an instance of DomainsClient, using the given settings. This is protected so that it is easy to make a subclass, but otherwise, the static factory methods should be preferred.
        Throws:
        IOException
      • DomainsClient

        protected DomainsClient​(DomainsStub stub)
    • Method Detail

      • create

        public static final DomainsClient create​(DomainsSettings settings)
                                          throws IOException
        Constructs an instance of DomainsClient, using the given settings. The channels are created based on the settings passed in, or defaults for any settings that are not set.
        Throws:
        IOException
      • create

        public static final DomainsClient create​(DomainsStub stub)
        Constructs an instance of DomainsClient, using the given stub for making calls. This is for advanced usage - prefer using create(DomainsSettings).
      • getOperationsClient

        public final com.google.longrunning.OperationsClient getOperationsClient()
        Returns the OperationsClient that can be used to query the status of a long-running operation returned by another API method call.
      • getHttpJsonOperationsClient

        @BetaApi
        public final com.google.api.gax.httpjson.longrunning.OperationsClient getHttpJsonOperationsClient()
        Returns the OperationsClient that can be used to query the status of a long-running operation returned by another API method call.
      • searchDomains

        public final SearchDomainsResponse searchDomains​(LocationName location,
                                                         String query)
        Searches for available domain names similar to the provided query.

        Availability results from this method are approximate; call `RetrieveRegisterParameters` on a domain before registering to confirm availability.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
           String query = "query107944136";
           SearchDomainsResponse response = domainsClient.searchDomains(location, query);
         }
         
        Parameters:
        location - Required. The location. Must be in the format `projects/*/locations/*`.
        query - Required. String used to search for available domain names.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • searchDomains

        public final SearchDomainsResponse searchDomains​(String location,
                                                         String query)
        Searches for available domain names similar to the provided query.

        Availability results from this method are approximate; call `RetrieveRegisterParameters` on a domain before registering to confirm availability.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String location = LocationName.of("[PROJECT]", "[LOCATION]").toString();
           String query = "query107944136";
           SearchDomainsResponse response = domainsClient.searchDomains(location, query);
         }
         
        Parameters:
        location - Required. The location. Must be in the format `projects/*/locations/*`.
        query - Required. String used to search for available domain names.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • searchDomains

        public final SearchDomainsResponse searchDomains​(SearchDomainsRequest request)
        Searches for available domain names similar to the provided query.

        Availability results from this method are approximate; call `RetrieveRegisterParameters` on a domain before registering to confirm availability.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           SearchDomainsRequest request =
               SearchDomainsRequest.newBuilder()
                   .setQuery("query107944136")
                   .setLocation(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .build();
           SearchDomainsResponse response = domainsClient.searchDomains(request);
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • searchDomainsCallable

        public final com.google.api.gax.rpc.UnaryCallable<SearchDomainsRequest,​SearchDomainsResponse> searchDomainsCallable()
        Searches for available domain names similar to the provided query.

        Availability results from this method are approximate; call `RetrieveRegisterParameters` on a domain before registering to confirm availability.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           SearchDomainsRequest request =
               SearchDomainsRequest.newBuilder()
                   .setQuery("query107944136")
                   .setLocation(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .build();
           ApiFuture<SearchDomainsResponse> future =
               domainsClient.searchDomainsCallable().futureCall(request);
           // Do something.
           SearchDomainsResponse response = future.get();
         }
         
      • retrieveRegisterParameters

        public final RetrieveRegisterParametersResponse retrieveRegisterParameters​(LocationName location,
                                                                                   String domainName)
        Gets parameters needed to register a new domain name, including price and up-to-date availability. Use the returned values to call `RegisterDomain`.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
           String domainName = "domainName-1244085905";
           RetrieveRegisterParametersResponse response =
               domainsClient.retrieveRegisterParameters(location, domainName);
         }
         
        Parameters:
        location - Required. The location. Must be in the format `projects/*/locations/*`.
        domainName - Required. The domain name. Unicode domain names must be expressed in Punycode format.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • retrieveRegisterParameters

        public final RetrieveRegisterParametersResponse retrieveRegisterParameters​(String location,
                                                                                   String domainName)
        Gets parameters needed to register a new domain name, including price and up-to-date availability. Use the returned values to call `RegisterDomain`.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String location = LocationName.of("[PROJECT]", "[LOCATION]").toString();
           String domainName = "domainName-1244085905";
           RetrieveRegisterParametersResponse response =
               domainsClient.retrieveRegisterParameters(location, domainName);
         }
         
        Parameters:
        location - Required. The location. Must be in the format `projects/*/locations/*`.
        domainName - Required. The domain name. Unicode domain names must be expressed in Punycode format.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • retrieveRegisterParameters

        public final RetrieveRegisterParametersResponse retrieveRegisterParameters​(RetrieveRegisterParametersRequest request)
        Gets parameters needed to register a new domain name, including price and up-to-date availability. Use the returned values to call `RegisterDomain`.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RetrieveRegisterParametersRequest request =
               RetrieveRegisterParametersRequest.newBuilder()
                   .setDomainName("domainName-1244085905")
                   .setLocation(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .build();
           RetrieveRegisterParametersResponse response =
               domainsClient.retrieveRegisterParameters(request);
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • retrieveRegisterParametersCallable

        public final com.google.api.gax.rpc.UnaryCallable<RetrieveRegisterParametersRequest,​RetrieveRegisterParametersResponse> retrieveRegisterParametersCallable()
        Gets parameters needed to register a new domain name, including price and up-to-date availability. Use the returned values to call `RegisterDomain`.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RetrieveRegisterParametersRequest request =
               RetrieveRegisterParametersRequest.newBuilder()
                   .setDomainName("domainName-1244085905")
                   .setLocation(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .build();
           ApiFuture<RetrieveRegisterParametersResponse> future =
               domainsClient.retrieveRegisterParametersCallable().futureCall(request);
           // Do something.
           RetrieveRegisterParametersResponse response = future.get();
         }
         
      • registerDomainAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> registerDomainAsync​(LocationName parent,
                                                                                                                              Registration registration,
                                                                                                                              com.google.type.Money yearlyPrice)
        Registers a new domain name and creates a corresponding `Registration` resource.

        Call `RetrieveRegisterParameters` first to check availability of the domain name and determine parameters like price that are needed to build a call to this method.

        A successful call creates a `Registration` resource in state `REGISTRATION_PENDING`, which resolves to `ACTIVE` within 1-2 minutes, indicating that the domain was successfully registered. If the resource ends up in state `REGISTRATION_FAILED`, it indicates that the domain was not registered successfully, and you can safely delete the resource and retry registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
           Registration registration = Registration.newBuilder().build();
           Money yearlyPrice = Money.newBuilder().build();
           Registration response =
               domainsClient.registerDomainAsync(parent, registration, yearlyPrice).get();
         }
         
        Parameters:
        parent - Required. The parent resource of the `Registration`. Must be in the format `projects/*/locations/*`.
        registration - Required. The complete `Registration` resource to be created.
        yearlyPrice - Required. Yearly price to register or renew the domain. The value that should be put here can be obtained from RetrieveRegisterParameters or SearchDomains calls.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • registerDomainAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> registerDomainAsync​(String parent,
                                                                                                                              Registration registration,
                                                                                                                              com.google.type.Money yearlyPrice)
        Registers a new domain name and creates a corresponding `Registration` resource.

        Call `RetrieveRegisterParameters` first to check availability of the domain name and determine parameters like price that are needed to build a call to this method.

        A successful call creates a `Registration` resource in state `REGISTRATION_PENDING`, which resolves to `ACTIVE` within 1-2 minutes, indicating that the domain was successfully registered. If the resource ends up in state `REGISTRATION_FAILED`, it indicates that the domain was not registered successfully, and you can safely delete the resource and retry registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String parent = LocationName.of("[PROJECT]", "[LOCATION]").toString();
           Registration registration = Registration.newBuilder().build();
           Money yearlyPrice = Money.newBuilder().build();
           Registration response =
               domainsClient.registerDomainAsync(parent, registration, yearlyPrice).get();
         }
         
        Parameters:
        parent - Required. The parent resource of the `Registration`. Must be in the format `projects/*/locations/*`.
        registration - Required. The complete `Registration` resource to be created.
        yearlyPrice - Required. Yearly price to register or renew the domain. The value that should be put here can be obtained from RetrieveRegisterParameters or SearchDomains calls.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • registerDomainAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> registerDomainAsync​(RegisterDomainRequest request)
        Registers a new domain name and creates a corresponding `Registration` resource.

        Call `RetrieveRegisterParameters` first to check availability of the domain name and determine parameters like price that are needed to build a call to this method.

        A successful call creates a `Registration` resource in state `REGISTRATION_PENDING`, which resolves to `ACTIVE` within 1-2 minutes, indicating that the domain was successfully registered. If the resource ends up in state `REGISTRATION_FAILED`, it indicates that the domain was not registered successfully, and you can safely delete the resource and retry registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RegisterDomainRequest request =
               RegisterDomainRequest.newBuilder()
                   .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .setRegistration(Registration.newBuilder().build())
                   .addAllDomainNotices(new ArrayList<DomainNotice>())
                   .addAllContactNotices(new ArrayList<ContactNotice>())
                   .setYearlyPrice(Money.newBuilder().build())
                   .setValidateOnly(true)
                   .build();
           Registration response = domainsClient.registerDomainAsync(request).get();
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • registerDomainOperationCallable

        public final com.google.api.gax.rpc.OperationCallable<RegisterDomainRequest,​Registration,​OperationMetadata> registerDomainOperationCallable()
        Registers a new domain name and creates a corresponding `Registration` resource.

        Call `RetrieveRegisterParameters` first to check availability of the domain name and determine parameters like price that are needed to build a call to this method.

        A successful call creates a `Registration` resource in state `REGISTRATION_PENDING`, which resolves to `ACTIVE` within 1-2 minutes, indicating that the domain was successfully registered. If the resource ends up in state `REGISTRATION_FAILED`, it indicates that the domain was not registered successfully, and you can safely delete the resource and retry registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RegisterDomainRequest request =
               RegisterDomainRequest.newBuilder()
                   .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .setRegistration(Registration.newBuilder().build())
                   .addAllDomainNotices(new ArrayList<DomainNotice>())
                   .addAllContactNotices(new ArrayList<ContactNotice>())
                   .setYearlyPrice(Money.newBuilder().build())
                   .setValidateOnly(true)
                   .build();
           OperationFuture<Registration, OperationMetadata> future =
               domainsClient.registerDomainOperationCallable().futureCall(request);
           // Do something.
           Registration response = future.get();
         }
         
      • registerDomainCallable

        public final com.google.api.gax.rpc.UnaryCallable<RegisterDomainRequest,​com.google.longrunning.Operation> registerDomainCallable()
        Registers a new domain name and creates a corresponding `Registration` resource.

        Call `RetrieveRegisterParameters` first to check availability of the domain name and determine parameters like price that are needed to build a call to this method.

        A successful call creates a `Registration` resource in state `REGISTRATION_PENDING`, which resolves to `ACTIVE` within 1-2 minutes, indicating that the domain was successfully registered. If the resource ends up in state `REGISTRATION_FAILED`, it indicates that the domain was not registered successfully, and you can safely delete the resource and retry registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RegisterDomainRequest request =
               RegisterDomainRequest.newBuilder()
                   .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .setRegistration(Registration.newBuilder().build())
                   .addAllDomainNotices(new ArrayList<DomainNotice>())
                   .addAllContactNotices(new ArrayList<ContactNotice>())
                   .setYearlyPrice(Money.newBuilder().build())
                   .setValidateOnly(true)
                   .build();
           ApiFuture<Operation> future = domainsClient.registerDomainCallable().futureCall(request);
           // Do something.
           Operation response = future.get();
         }
         
      • retrieveTransferParameters

        public final RetrieveTransferParametersResponse retrieveTransferParameters​(LocationName location,
                                                                                   String domainName)
        Gets parameters needed to transfer a domain name from another registrar to Cloud Domains. For domains managed by Google Domains, transferring to Cloud Domains is not supported.

        Use the returned values to call `TransferDomain`.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
           String domainName = "domainName-1244085905";
           RetrieveTransferParametersResponse response =
               domainsClient.retrieveTransferParameters(location, domainName);
         }
         
        Parameters:
        location - Required. The location. Must be in the format `projects/*/locations/*`.
        domainName - Required. The domain name. Unicode domain names must be expressed in Punycode format.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • retrieveTransferParameters

        public final RetrieveTransferParametersResponse retrieveTransferParameters​(String location,
                                                                                   String domainName)
        Gets parameters needed to transfer a domain name from another registrar to Cloud Domains. For domains managed by Google Domains, transferring to Cloud Domains is not supported.

        Use the returned values to call `TransferDomain`.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String location = LocationName.of("[PROJECT]", "[LOCATION]").toString();
           String domainName = "domainName-1244085905";
           RetrieveTransferParametersResponse response =
               domainsClient.retrieveTransferParameters(location, domainName);
         }
         
        Parameters:
        location - Required. The location. Must be in the format `projects/*/locations/*`.
        domainName - Required. The domain name. Unicode domain names must be expressed in Punycode format.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • retrieveTransferParameters

        public final RetrieveTransferParametersResponse retrieveTransferParameters​(RetrieveTransferParametersRequest request)
        Gets parameters needed to transfer a domain name from another registrar to Cloud Domains. For domains managed by Google Domains, transferring to Cloud Domains is not supported.

        Use the returned values to call `TransferDomain`.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RetrieveTransferParametersRequest request =
               RetrieveTransferParametersRequest.newBuilder()
                   .setDomainName("domainName-1244085905")
                   .setLocation(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .build();
           RetrieveTransferParametersResponse response =
               domainsClient.retrieveTransferParameters(request);
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • retrieveTransferParametersCallable

        public final com.google.api.gax.rpc.UnaryCallable<RetrieveTransferParametersRequest,​RetrieveTransferParametersResponse> retrieveTransferParametersCallable()
        Gets parameters needed to transfer a domain name from another registrar to Cloud Domains. For domains managed by Google Domains, transferring to Cloud Domains is not supported.

        Use the returned values to call `TransferDomain`.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RetrieveTransferParametersRequest request =
               RetrieveTransferParametersRequest.newBuilder()
                   .setDomainName("domainName-1244085905")
                   .setLocation(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .build();
           ApiFuture<RetrieveTransferParametersResponse> future =
               domainsClient.retrieveTransferParametersCallable().futureCall(request);
           // Do something.
           RetrieveTransferParametersResponse response = future.get();
         }
         
      • transferDomainAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> transferDomainAsync​(LocationName parent,
                                                                                                                              Registration registration,
                                                                                                                              com.google.type.Money yearlyPrice,
                                                                                                                              AuthorizationCode authorizationCode)
        Transfers a domain name from another registrar to Cloud Domains. For domains managed by Google Domains, transferring to Cloud Domains is not supported.

        Before calling this method, go to the domain's current registrar to unlock the domain for transfer and retrieve the domain's transfer authorization code. Then call `RetrieveTransferParameters` to confirm that the domain is unlocked and to get values needed to build a call to this method.

        A successful call creates a `Registration` resource in state `TRANSFER_PENDING`. It can take several days to complete the transfer process. The registrant can often speed up this process by approving the transfer through the current registrar, either by clicking a link in an email from the registrar or by visiting the registrar's website.

        A few minutes after transfer approval, the resource transitions to state `ACTIVE`, indicating that the transfer was successful. If the transfer is rejected or the request expires without being approved, the resource can end up in state `TRANSFER_FAILED`. If transfer fails, you can safely delete the resource and retry the transfer.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
           Registration registration = Registration.newBuilder().build();
           Money yearlyPrice = Money.newBuilder().build();
           AuthorizationCode authorizationCode = AuthorizationCode.newBuilder().build();
           Registration response =
               domainsClient
                   .transferDomainAsync(parent, registration, yearlyPrice, authorizationCode)
                   .get();
         }
         
        Parameters:
        parent - Required. The parent resource of the `Registration`. Must be in the format `projects/*/locations/*`.
        registration - Required. The complete `Registration` resource to be created.

        You can leave `registration.dns_settings` unset to import the domain's current DNS configuration from its current registrar. Use this option only if you are sure that the domain's current DNS service does not cease upon transfer, as is often the case for DNS services provided for free by the registrar.

        yearlyPrice - Required. Acknowledgement of the price to transfer or renew the domain for one year. Call `RetrieveTransferParameters` to obtain the price, which you must acknowledge.
        authorizationCode - The domain's transfer authorization code. You can obtain this from the domain's current registrar.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • transferDomainAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> transferDomainAsync​(String parent,
                                                                                                                              Registration registration,
                                                                                                                              com.google.type.Money yearlyPrice,
                                                                                                                              AuthorizationCode authorizationCode)
        Transfers a domain name from another registrar to Cloud Domains. For domains managed by Google Domains, transferring to Cloud Domains is not supported.

        Before calling this method, go to the domain's current registrar to unlock the domain for transfer and retrieve the domain's transfer authorization code. Then call `RetrieveTransferParameters` to confirm that the domain is unlocked and to get values needed to build a call to this method.

        A successful call creates a `Registration` resource in state `TRANSFER_PENDING`. It can take several days to complete the transfer process. The registrant can often speed up this process by approving the transfer through the current registrar, either by clicking a link in an email from the registrar or by visiting the registrar's website.

        A few minutes after transfer approval, the resource transitions to state `ACTIVE`, indicating that the transfer was successful. If the transfer is rejected or the request expires without being approved, the resource can end up in state `TRANSFER_FAILED`. If transfer fails, you can safely delete the resource and retry the transfer.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String parent = LocationName.of("[PROJECT]", "[LOCATION]").toString();
           Registration registration = Registration.newBuilder().build();
           Money yearlyPrice = Money.newBuilder().build();
           AuthorizationCode authorizationCode = AuthorizationCode.newBuilder().build();
           Registration response =
               domainsClient
                   .transferDomainAsync(parent, registration, yearlyPrice, authorizationCode)
                   .get();
         }
         
        Parameters:
        parent - Required. The parent resource of the `Registration`. Must be in the format `projects/*/locations/*`.
        registration - Required. The complete `Registration` resource to be created.

        You can leave `registration.dns_settings` unset to import the domain's current DNS configuration from its current registrar. Use this option only if you are sure that the domain's current DNS service does not cease upon transfer, as is often the case for DNS services provided for free by the registrar.

        yearlyPrice - Required. Acknowledgement of the price to transfer or renew the domain for one year. Call `RetrieveTransferParameters` to obtain the price, which you must acknowledge.
        authorizationCode - The domain's transfer authorization code. You can obtain this from the domain's current registrar.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • transferDomainAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> transferDomainAsync​(TransferDomainRequest request)
        Transfers a domain name from another registrar to Cloud Domains. For domains managed by Google Domains, transferring to Cloud Domains is not supported.

        Before calling this method, go to the domain's current registrar to unlock the domain for transfer and retrieve the domain's transfer authorization code. Then call `RetrieveTransferParameters` to confirm that the domain is unlocked and to get values needed to build a call to this method.

        A successful call creates a `Registration` resource in state `TRANSFER_PENDING`. It can take several days to complete the transfer process. The registrant can often speed up this process by approving the transfer through the current registrar, either by clicking a link in an email from the registrar or by visiting the registrar's website.

        A few minutes after transfer approval, the resource transitions to state `ACTIVE`, indicating that the transfer was successful. If the transfer is rejected or the request expires without being approved, the resource can end up in state `TRANSFER_FAILED`. If transfer fails, you can safely delete the resource and retry the transfer.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           TransferDomainRequest request =
               TransferDomainRequest.newBuilder()
                   .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .setRegistration(Registration.newBuilder().build())
                   .addAllContactNotices(new ArrayList<ContactNotice>())
                   .setYearlyPrice(Money.newBuilder().build())
                   .setAuthorizationCode(AuthorizationCode.newBuilder().build())
                   .setValidateOnly(true)
                   .build();
           Registration response = domainsClient.transferDomainAsync(request).get();
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • transferDomainOperationCallable

        public final com.google.api.gax.rpc.OperationCallable<TransferDomainRequest,​Registration,​OperationMetadata> transferDomainOperationCallable()
        Transfers a domain name from another registrar to Cloud Domains. For domains managed by Google Domains, transferring to Cloud Domains is not supported.

        Before calling this method, go to the domain's current registrar to unlock the domain for transfer and retrieve the domain's transfer authorization code. Then call `RetrieveTransferParameters` to confirm that the domain is unlocked and to get values needed to build a call to this method.

        A successful call creates a `Registration` resource in state `TRANSFER_PENDING`. It can take several days to complete the transfer process. The registrant can often speed up this process by approving the transfer through the current registrar, either by clicking a link in an email from the registrar or by visiting the registrar's website.

        A few minutes after transfer approval, the resource transitions to state `ACTIVE`, indicating that the transfer was successful. If the transfer is rejected or the request expires without being approved, the resource can end up in state `TRANSFER_FAILED`. If transfer fails, you can safely delete the resource and retry the transfer.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           TransferDomainRequest request =
               TransferDomainRequest.newBuilder()
                   .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .setRegistration(Registration.newBuilder().build())
                   .addAllContactNotices(new ArrayList<ContactNotice>())
                   .setYearlyPrice(Money.newBuilder().build())
                   .setAuthorizationCode(AuthorizationCode.newBuilder().build())
                   .setValidateOnly(true)
                   .build();
           OperationFuture<Registration, OperationMetadata> future =
               domainsClient.transferDomainOperationCallable().futureCall(request);
           // Do something.
           Registration response = future.get();
         }
         
      • transferDomainCallable

        public final com.google.api.gax.rpc.UnaryCallable<TransferDomainRequest,​com.google.longrunning.Operation> transferDomainCallable()
        Transfers a domain name from another registrar to Cloud Domains. For domains managed by Google Domains, transferring to Cloud Domains is not supported.

        Before calling this method, go to the domain's current registrar to unlock the domain for transfer and retrieve the domain's transfer authorization code. Then call `RetrieveTransferParameters` to confirm that the domain is unlocked and to get values needed to build a call to this method.

        A successful call creates a `Registration` resource in state `TRANSFER_PENDING`. It can take several days to complete the transfer process. The registrant can often speed up this process by approving the transfer through the current registrar, either by clicking a link in an email from the registrar or by visiting the registrar's website.

        A few minutes after transfer approval, the resource transitions to state `ACTIVE`, indicating that the transfer was successful. If the transfer is rejected or the request expires without being approved, the resource can end up in state `TRANSFER_FAILED`. If transfer fails, you can safely delete the resource and retry the transfer.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           TransferDomainRequest request =
               TransferDomainRequest.newBuilder()
                   .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .setRegistration(Registration.newBuilder().build())
                   .addAllContactNotices(new ArrayList<ContactNotice>())
                   .setYearlyPrice(Money.newBuilder().build())
                   .setAuthorizationCode(AuthorizationCode.newBuilder().build())
                   .setValidateOnly(true)
                   .build();
           ApiFuture<Operation> future = domainsClient.transferDomainCallable().futureCall(request);
           // Do something.
           Operation response = future.get();
         }
         
      • listRegistrations

        public final DomainsClient.ListRegistrationsPagedResponse listRegistrations​(LocationName parent)
        Lists the `Registration` resources in a project.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
           for (Registration element : domainsClient.listRegistrations(parent).iterateAll()) {
             // doThingsWith(element);
           }
         }
         
        Parameters:
        parent - Required. The project and location from which to list `Registration`s, specified in the format `projects/*/locations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • listRegistrations

        public final DomainsClient.ListRegistrationsPagedResponse listRegistrations​(String parent)
        Lists the `Registration` resources in a project.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String parent = LocationName.of("[PROJECT]", "[LOCATION]").toString();
           for (Registration element : domainsClient.listRegistrations(parent).iterateAll()) {
             // doThingsWith(element);
           }
         }
         
        Parameters:
        parent - Required. The project and location from which to list `Registration`s, specified in the format `projects/*/locations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • listRegistrations

        public final DomainsClient.ListRegistrationsPagedResponse listRegistrations​(ListRegistrationsRequest request)
        Lists the `Registration` resources in a project.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ListRegistrationsRequest request =
               ListRegistrationsRequest.newBuilder()
                   .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .setPageSize(883849137)
                   .setPageToken("pageToken873572522")
                   .setFilter("filter-1274492040")
                   .build();
           for (Registration element : domainsClient.listRegistrations(request).iterateAll()) {
             // doThingsWith(element);
           }
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • listRegistrationsPagedCallable

        public final com.google.api.gax.rpc.UnaryCallable<ListRegistrationsRequest,​DomainsClient.ListRegistrationsPagedResponse> listRegistrationsPagedCallable()
        Lists the `Registration` resources in a project.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ListRegistrationsRequest request =
               ListRegistrationsRequest.newBuilder()
                   .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .setPageSize(883849137)
                   .setPageToken("pageToken873572522")
                   .setFilter("filter-1274492040")
                   .build();
           ApiFuture<Registration> future =
               domainsClient.listRegistrationsPagedCallable().futureCall(request);
           // Do something.
           for (Registration element : future.get().iterateAll()) {
             // doThingsWith(element);
           }
         }
         
      • listRegistrationsCallable

        public final com.google.api.gax.rpc.UnaryCallable<ListRegistrationsRequest,​ListRegistrationsResponse> listRegistrationsCallable()
        Lists the `Registration` resources in a project.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ListRegistrationsRequest request =
               ListRegistrationsRequest.newBuilder()
                   .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
                   .setPageSize(883849137)
                   .setPageToken("pageToken873572522")
                   .setFilter("filter-1274492040")
                   .build();
           while (true) {
             ListRegistrationsResponse response =
                 domainsClient.listRegistrationsCallable().call(request);
             for (Registration element : response.getRegistrationsList()) {
               // doThingsWith(element);
             }
             String nextPageToken = response.getNextPageToken();
             if (!Strings.isNullOrEmpty(nextPageToken)) {
               request = request.toBuilder().setPageToken(nextPageToken).build();
             } else {
               break;
             }
           }
         }
         
      • getRegistration

        public final Registration getRegistration​(RegistrationName name)
        Gets the details of a `Registration` resource.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RegistrationName name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
           Registration response = domainsClient.getRegistration(name);
         }
         
        Parameters:
        name - Required. The name of the `Registration` to get, in the format `projects/*/locations/*/registrations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • getRegistration

        public final Registration getRegistration​(String name)
        Gets the details of a `Registration` resource.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString();
           Registration response = domainsClient.getRegistration(name);
         }
         
        Parameters:
        name - Required. The name of the `Registration` to get, in the format `projects/*/locations/*/registrations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • getRegistration

        public final Registration getRegistration​(GetRegistrationRequest request)
        Gets the details of a `Registration` resource.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           GetRegistrationRequest request =
               GetRegistrationRequest.newBuilder()
                   .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           Registration response = domainsClient.getRegistration(request);
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • getRegistrationCallable

        public final com.google.api.gax.rpc.UnaryCallable<GetRegistrationRequest,​Registration> getRegistrationCallable()
        Gets the details of a `Registration` resource.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           GetRegistrationRequest request =
               GetRegistrationRequest.newBuilder()
                   .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           ApiFuture<Registration> future = domainsClient.getRegistrationCallable().futureCall(request);
           // Do something.
           Registration response = future.get();
         }
         
      • updateRegistrationAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> updateRegistrationAsync​(Registration registration,
                                                                                                                                  com.google.protobuf.FieldMask updateMask)
        Updates select fields of a `Registration` resource, notably `labels`. To update other fields, use the appropriate custom update method:
        • To update management settings, see `ConfigureManagementSettings`
        • To update DNS configuration, see `ConfigureDnsSettings`
        • To update contact information, see `ConfigureContactSettings`

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           Registration registration = Registration.newBuilder().build();
           FieldMask updateMask = FieldMask.newBuilder().build();
           Registration response = domainsClient.updateRegistrationAsync(registration, updateMask).get();
         }
         
        Parameters:
        registration - Fields of the `Registration` to update.
        updateMask - Required. The field mask describing which fields to update as a comma-separated list. For example, if only the labels are being updated, the `update_mask` is `"labels"`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • updateRegistrationAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> updateRegistrationAsync​(UpdateRegistrationRequest request)
        Updates select fields of a `Registration` resource, notably `labels`. To update other fields, use the appropriate custom update method:
        • To update management settings, see `ConfigureManagementSettings`
        • To update DNS configuration, see `ConfigureDnsSettings`
        • To update contact information, see `ConfigureContactSettings`

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           UpdateRegistrationRequest request =
               UpdateRegistrationRequest.newBuilder()
                   .setRegistration(Registration.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .build();
           Registration response = domainsClient.updateRegistrationAsync(request).get();
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • updateRegistrationOperationCallable

        public final com.google.api.gax.rpc.OperationCallable<UpdateRegistrationRequest,​Registration,​OperationMetadata> updateRegistrationOperationCallable()
        Updates select fields of a `Registration` resource, notably `labels`. To update other fields, use the appropriate custom update method:
        • To update management settings, see `ConfigureManagementSettings`
        • To update DNS configuration, see `ConfigureDnsSettings`
        • To update contact information, see `ConfigureContactSettings`

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           UpdateRegistrationRequest request =
               UpdateRegistrationRequest.newBuilder()
                   .setRegistration(Registration.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .build();
           OperationFuture<Registration, OperationMetadata> future =
               domainsClient.updateRegistrationOperationCallable().futureCall(request);
           // Do something.
           Registration response = future.get();
         }
         
      • updateRegistrationCallable

        public final com.google.api.gax.rpc.UnaryCallable<UpdateRegistrationRequest,​com.google.longrunning.Operation> updateRegistrationCallable()
        Updates select fields of a `Registration` resource, notably `labels`. To update other fields, use the appropriate custom update method:
        • To update management settings, see `ConfigureManagementSettings`
        • To update DNS configuration, see `ConfigureDnsSettings`
        • To update contact information, see `ConfigureContactSettings`

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           UpdateRegistrationRequest request =
               UpdateRegistrationRequest.newBuilder()
                   .setRegistration(Registration.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .build();
           ApiFuture<Operation> future = domainsClient.updateRegistrationCallable().futureCall(request);
           // Do something.
           Operation response = future.get();
         }
         
      • configureManagementSettingsAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> configureManagementSettingsAsync​(RegistrationName registration,
                                                                                                                                           ManagementSettings managementSettings,
                                                                                                                                           com.google.protobuf.FieldMask updateMask)
        Updates a `Registration`'s management settings.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RegistrationName registration =
               RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
           ManagementSettings managementSettings = ManagementSettings.newBuilder().build();
           FieldMask updateMask = FieldMask.newBuilder().build();
           Registration response =
               domainsClient
                   .configureManagementSettingsAsync(registration, managementSettings, updateMask)
                   .get();
         }
         
        Parameters:
        registration - Required. The name of the `Registration` whose management settings are being updated, in the format `projects/*/locations/*/registrations/*`.
        managementSettings - Fields of the `ManagementSettings` to update.
        updateMask - Required. The field mask describing which fields to update as a comma-separated list. For example, if only the transfer lock is being updated, the `update_mask` is `"transfer_lock_state"`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • configureManagementSettingsAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> configureManagementSettingsAsync​(String registration,
                                                                                                                                           ManagementSettings managementSettings,
                                                                                                                                           com.google.protobuf.FieldMask updateMask)
        Updates a `Registration`'s management settings.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String registration =
               RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString();
           ManagementSettings managementSettings = ManagementSettings.newBuilder().build();
           FieldMask updateMask = FieldMask.newBuilder().build();
           Registration response =
               domainsClient
                   .configureManagementSettingsAsync(registration, managementSettings, updateMask)
                   .get();
         }
         
        Parameters:
        registration - Required. The name of the `Registration` whose management settings are being updated, in the format `projects/*/locations/*/registrations/*`.
        managementSettings - Fields of the `ManagementSettings` to update.
        updateMask - Required. The field mask describing which fields to update as a comma-separated list. For example, if only the transfer lock is being updated, the `update_mask` is `"transfer_lock_state"`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • configureManagementSettingsAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> configureManagementSettingsAsync​(ConfigureManagementSettingsRequest request)
        Updates a `Registration`'s management settings.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ConfigureManagementSettingsRequest request =
               ConfigureManagementSettingsRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .setManagementSettings(ManagementSettings.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .build();
           Registration response = domainsClient.configureManagementSettingsAsync(request).get();
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • configureManagementSettingsOperationCallable

        public final com.google.api.gax.rpc.OperationCallable<ConfigureManagementSettingsRequest,​Registration,​OperationMetadata> configureManagementSettingsOperationCallable()
        Updates a `Registration`'s management settings.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ConfigureManagementSettingsRequest request =
               ConfigureManagementSettingsRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .setManagementSettings(ManagementSettings.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .build();
           OperationFuture<Registration, OperationMetadata> future =
               domainsClient.configureManagementSettingsOperationCallable().futureCall(request);
           // Do something.
           Registration response = future.get();
         }
         
      • configureManagementSettingsCallable

        public final com.google.api.gax.rpc.UnaryCallable<ConfigureManagementSettingsRequest,​com.google.longrunning.Operation> configureManagementSettingsCallable()
        Updates a `Registration`'s management settings.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ConfigureManagementSettingsRequest request =
               ConfigureManagementSettingsRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .setManagementSettings(ManagementSettings.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .build();
           ApiFuture<Operation> future =
               domainsClient.configureManagementSettingsCallable().futureCall(request);
           // Do something.
           Operation response = future.get();
         }
         
      • configureDnsSettingsAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> configureDnsSettingsAsync​(RegistrationName registration,
                                                                                                                                    DnsSettings dnsSettings,
                                                                                                                                    com.google.protobuf.FieldMask updateMask)
        Updates a `Registration`'s DNS settings.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RegistrationName registration =
               RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
           DnsSettings dnsSettings = DnsSettings.newBuilder().build();
           FieldMask updateMask = FieldMask.newBuilder().build();
           Registration response =
               domainsClient.configureDnsSettingsAsync(registration, dnsSettings, updateMask).get();
         }
         
        Parameters:
        registration - Required. The name of the `Registration` whose DNS settings are being updated, in the format `projects/*/locations/*/registrations/*`.
        dnsSettings - Fields of the `DnsSettings` to update.
        updateMask - Required. The field mask describing which fields to update as a comma-separated list. For example, if only the name servers are being updated for an existing Custom DNS configuration, the `update_mask` is `"custom_dns.name_servers"`.

        When changing the DNS provider from one type to another, pass the new provider's field name as part of the field mask. For example, when changing from a Google Domains DNS configuration to a Custom DNS configuration, the `update_mask` is `"custom_dns"`. //

        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • configureDnsSettingsAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> configureDnsSettingsAsync​(String registration,
                                                                                                                                    DnsSettings dnsSettings,
                                                                                                                                    com.google.protobuf.FieldMask updateMask)
        Updates a `Registration`'s DNS settings.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String registration =
               RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString();
           DnsSettings dnsSettings = DnsSettings.newBuilder().build();
           FieldMask updateMask = FieldMask.newBuilder().build();
           Registration response =
               domainsClient.configureDnsSettingsAsync(registration, dnsSettings, updateMask).get();
         }
         
        Parameters:
        registration - Required. The name of the `Registration` whose DNS settings are being updated, in the format `projects/*/locations/*/registrations/*`.
        dnsSettings - Fields of the `DnsSettings` to update.
        updateMask - Required. The field mask describing which fields to update as a comma-separated list. For example, if only the name servers are being updated for an existing Custom DNS configuration, the `update_mask` is `"custom_dns.name_servers"`.

        When changing the DNS provider from one type to another, pass the new provider's field name as part of the field mask. For example, when changing from a Google Domains DNS configuration to a Custom DNS configuration, the `update_mask` is `"custom_dns"`. //

        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • configureDnsSettingsAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> configureDnsSettingsAsync​(ConfigureDnsSettingsRequest request)
        Updates a `Registration`'s DNS settings.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ConfigureDnsSettingsRequest request =
               ConfigureDnsSettingsRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .setDnsSettings(DnsSettings.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .setValidateOnly(true)
                   .build();
           Registration response = domainsClient.configureDnsSettingsAsync(request).get();
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • configureDnsSettingsOperationCallable

        public final com.google.api.gax.rpc.OperationCallable<ConfigureDnsSettingsRequest,​Registration,​OperationMetadata> configureDnsSettingsOperationCallable()
        Updates a `Registration`'s DNS settings.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ConfigureDnsSettingsRequest request =
               ConfigureDnsSettingsRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .setDnsSettings(DnsSettings.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .setValidateOnly(true)
                   .build();
           OperationFuture<Registration, OperationMetadata> future =
               domainsClient.configureDnsSettingsOperationCallable().futureCall(request);
           // Do something.
           Registration response = future.get();
         }
         
      • configureDnsSettingsCallable

        public final com.google.api.gax.rpc.UnaryCallable<ConfigureDnsSettingsRequest,​com.google.longrunning.Operation> configureDnsSettingsCallable()
        Updates a `Registration`'s DNS settings.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ConfigureDnsSettingsRequest request =
               ConfigureDnsSettingsRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .setDnsSettings(DnsSettings.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .setValidateOnly(true)
                   .build();
           ApiFuture<Operation> future =
               domainsClient.configureDnsSettingsCallable().futureCall(request);
           // Do something.
           Operation response = future.get();
         }
         
      • configureContactSettingsAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> configureContactSettingsAsync​(RegistrationName registration,
                                                                                                                                        ContactSettings contactSettings,
                                                                                                                                        com.google.protobuf.FieldMask updateMask)
        Updates a `Registration`'s contact settings. Some changes require confirmation by the domain's registrant contact .

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RegistrationName registration =
               RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
           ContactSettings contactSettings = ContactSettings.newBuilder().build();
           FieldMask updateMask = FieldMask.newBuilder().build();
           Registration response =
               domainsClient
                   .configureContactSettingsAsync(registration, contactSettings, updateMask)
                   .get();
         }
         
        Parameters:
        registration - Required. The name of the `Registration` whose contact settings are being updated, in the format `projects/*/locations/*/registrations/*`.
        contactSettings - Fields of the `ContactSettings` to update.
        updateMask - Required. The field mask describing which fields to update as a comma-separated list. For example, if only the registrant contact is being updated, the `update_mask` is `"registrant_contact"`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • configureContactSettingsAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> configureContactSettingsAsync​(String registration,
                                                                                                                                        ContactSettings contactSettings,
                                                                                                                                        com.google.protobuf.FieldMask updateMask)
        Updates a `Registration`'s contact settings. Some changes require confirmation by the domain's registrant contact .

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String registration =
               RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString();
           ContactSettings contactSettings = ContactSettings.newBuilder().build();
           FieldMask updateMask = FieldMask.newBuilder().build();
           Registration response =
               domainsClient
                   .configureContactSettingsAsync(registration, contactSettings, updateMask)
                   .get();
         }
         
        Parameters:
        registration - Required. The name of the `Registration` whose contact settings are being updated, in the format `projects/*/locations/*/registrations/*`.
        contactSettings - Fields of the `ContactSettings` to update.
        updateMask - Required. The field mask describing which fields to update as a comma-separated list. For example, if only the registrant contact is being updated, the `update_mask` is `"registrant_contact"`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • configureContactSettingsAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> configureContactSettingsAsync​(ConfigureContactSettingsRequest request)
        Updates a `Registration`'s contact settings. Some changes require confirmation by the domain's registrant contact .

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ConfigureContactSettingsRequest request =
               ConfigureContactSettingsRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .setContactSettings(ContactSettings.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .addAllContactNotices(new ArrayList<ContactNotice>())
                   .setValidateOnly(true)
                   .build();
           Registration response = domainsClient.configureContactSettingsAsync(request).get();
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • configureContactSettingsOperationCallable

        public final com.google.api.gax.rpc.OperationCallable<ConfigureContactSettingsRequest,​Registration,​OperationMetadata> configureContactSettingsOperationCallable()
        Updates a `Registration`'s contact settings. Some changes require confirmation by the domain's registrant contact .

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ConfigureContactSettingsRequest request =
               ConfigureContactSettingsRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .setContactSettings(ContactSettings.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .addAllContactNotices(new ArrayList<ContactNotice>())
                   .setValidateOnly(true)
                   .build();
           OperationFuture<Registration, OperationMetadata> future =
               domainsClient.configureContactSettingsOperationCallable().futureCall(request);
           // Do something.
           Registration response = future.get();
         }
         
      • configureContactSettingsCallable

        public final com.google.api.gax.rpc.UnaryCallable<ConfigureContactSettingsRequest,​com.google.longrunning.Operation> configureContactSettingsCallable()
        Updates a `Registration`'s contact settings. Some changes require confirmation by the domain's registrant contact .

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ConfigureContactSettingsRequest request =
               ConfigureContactSettingsRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .setContactSettings(ContactSettings.newBuilder().build())
                   .setUpdateMask(FieldMask.newBuilder().build())
                   .addAllContactNotices(new ArrayList<ContactNotice>())
                   .setValidateOnly(true)
                   .build();
           ApiFuture<Operation> future =
               domainsClient.configureContactSettingsCallable().futureCall(request);
           // Do something.
           Operation response = future.get();
         }
         
      • exportRegistrationAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> exportRegistrationAsync​(RegistrationName name)
        Exports a `Registration` resource, such that it is no longer managed by Cloud Domains.

        When an active domain is successfully exported, you can continue to use the domain in [Google Domains](https://domains.google/) until it expires. The calling user becomes the domain's sole owner in Google Domains, and permissions for the domain are subsequently managed there. The domain does not renew automatically unless the new owner sets up billing in Google Domains.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RegistrationName name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
           Registration response = domainsClient.exportRegistrationAsync(name).get();
         }
         
        Parameters:
        name - Required. The name of the `Registration` to export, in the format `projects/*/locations/*/registrations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • exportRegistrationAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> exportRegistrationAsync​(String name)
        Exports a `Registration` resource, such that it is no longer managed by Cloud Domains.

        When an active domain is successfully exported, you can continue to use the domain in [Google Domains](https://domains.google/) until it expires. The calling user becomes the domain's sole owner in Google Domains, and permissions for the domain are subsequently managed there. The domain does not renew automatically unless the new owner sets up billing in Google Domains.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString();
           Registration response = domainsClient.exportRegistrationAsync(name).get();
         }
         
        Parameters:
        name - Required. The name of the `Registration` to export, in the format `projects/*/locations/*/registrations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • exportRegistrationAsync

        public final com.google.api.gax.longrunning.OperationFuture<Registration,​OperationMetadata> exportRegistrationAsync​(ExportRegistrationRequest request)
        Exports a `Registration` resource, such that it is no longer managed by Cloud Domains.

        When an active domain is successfully exported, you can continue to use the domain in [Google Domains](https://domains.google/) until it expires. The calling user becomes the domain's sole owner in Google Domains, and permissions for the domain are subsequently managed there. The domain does not renew automatically unless the new owner sets up billing in Google Domains.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ExportRegistrationRequest request =
               ExportRegistrationRequest.newBuilder()
                   .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           Registration response = domainsClient.exportRegistrationAsync(request).get();
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • exportRegistrationOperationCallable

        public final com.google.api.gax.rpc.OperationCallable<ExportRegistrationRequest,​Registration,​OperationMetadata> exportRegistrationOperationCallable()
        Exports a `Registration` resource, such that it is no longer managed by Cloud Domains.

        When an active domain is successfully exported, you can continue to use the domain in [Google Domains](https://domains.google/) until it expires. The calling user becomes the domain's sole owner in Google Domains, and permissions for the domain are subsequently managed there. The domain does not renew automatically unless the new owner sets up billing in Google Domains.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ExportRegistrationRequest request =
               ExportRegistrationRequest.newBuilder()
                   .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           OperationFuture<Registration, OperationMetadata> future =
               domainsClient.exportRegistrationOperationCallable().futureCall(request);
           // Do something.
           Registration response = future.get();
         }
         
      • exportRegistrationCallable

        public final com.google.api.gax.rpc.UnaryCallable<ExportRegistrationRequest,​com.google.longrunning.Operation> exportRegistrationCallable()
        Exports a `Registration` resource, such that it is no longer managed by Cloud Domains.

        When an active domain is successfully exported, you can continue to use the domain in [Google Domains](https://domains.google/) until it expires. The calling user becomes the domain's sole owner in Google Domains, and permissions for the domain are subsequently managed there. The domain does not renew automatically unless the new owner sets up billing in Google Domains.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ExportRegistrationRequest request =
               ExportRegistrationRequest.newBuilder()
                   .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           ApiFuture<Operation> future = domainsClient.exportRegistrationCallable().futureCall(request);
           // Do something.
           Operation response = future.get();
         }
         
      • deleteRegistrationAsync

        public final com.google.api.gax.longrunning.OperationFuture<com.google.protobuf.Empty,​OperationMetadata> deleteRegistrationAsync​(RegistrationName name)
        Deletes a `Registration` resource.

        This method works on any `Registration` resource using [Subscription or Commitment billing](/domains/pricing#billing-models), provided that the resource was created at least 1 day in the past.

        For `Registration` resources using [Monthly billing](/domains/pricing#billing-models), this method works if:

        • `state` is `EXPORTED` with `expire_time` in the past
        • `state` is `REGISTRATION_FAILED`
        • `state` is `TRANSFER_FAILED`

        When an active registration is successfully deleted, you can continue to use the domain in [Google Domains](https://domains.google/) until it expires. The calling user becomes the domain's sole owner in Google Domains, and permissions for the domain are subsequently managed there. The domain does not renew automatically unless the new owner sets up billing in Google Domains.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RegistrationName name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
           domainsClient.deleteRegistrationAsync(name).get();
         }
         
        Parameters:
        name - Required. The name of the `Registration` to delete, in the format `projects/*/locations/*/registrations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • deleteRegistrationAsync

        public final com.google.api.gax.longrunning.OperationFuture<com.google.protobuf.Empty,​OperationMetadata> deleteRegistrationAsync​(String name)
        Deletes a `Registration` resource.

        This method works on any `Registration` resource using [Subscription or Commitment billing](/domains/pricing#billing-models), provided that the resource was created at least 1 day in the past.

        For `Registration` resources using [Monthly billing](/domains/pricing#billing-models), this method works if:

        • `state` is `EXPORTED` with `expire_time` in the past
        • `state` is `REGISTRATION_FAILED`
        • `state` is `TRANSFER_FAILED`

        When an active registration is successfully deleted, you can continue to use the domain in [Google Domains](https://domains.google/) until it expires. The calling user becomes the domain's sole owner in Google Domains, and permissions for the domain are subsequently managed there. The domain does not renew automatically unless the new owner sets up billing in Google Domains.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString();
           domainsClient.deleteRegistrationAsync(name).get();
         }
         
        Parameters:
        name - Required. The name of the `Registration` to delete, in the format `projects/*/locations/*/registrations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • deleteRegistrationAsync

        public final com.google.api.gax.longrunning.OperationFuture<com.google.protobuf.Empty,​OperationMetadata> deleteRegistrationAsync​(DeleteRegistrationRequest request)
        Deletes a `Registration` resource.

        This method works on any `Registration` resource using [Subscription or Commitment billing](/domains/pricing#billing-models), provided that the resource was created at least 1 day in the past.

        For `Registration` resources using [Monthly billing](/domains/pricing#billing-models), this method works if:

        • `state` is `EXPORTED` with `expire_time` in the past
        • `state` is `REGISTRATION_FAILED`
        • `state` is `TRANSFER_FAILED`

        When an active registration is successfully deleted, you can continue to use the domain in [Google Domains](https://domains.google/) until it expires. The calling user becomes the domain's sole owner in Google Domains, and permissions for the domain are subsequently managed there. The domain does not renew automatically unless the new owner sets up billing in Google Domains.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           DeleteRegistrationRequest request =
               DeleteRegistrationRequest.newBuilder()
                   .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           domainsClient.deleteRegistrationAsync(request).get();
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • deleteRegistrationOperationCallable

        public final com.google.api.gax.rpc.OperationCallable<DeleteRegistrationRequest,​com.google.protobuf.Empty,​OperationMetadata> deleteRegistrationOperationCallable()
        Deletes a `Registration` resource.

        This method works on any `Registration` resource using [Subscription or Commitment billing](/domains/pricing#billing-models), provided that the resource was created at least 1 day in the past.

        For `Registration` resources using [Monthly billing](/domains/pricing#billing-models), this method works if:

        • `state` is `EXPORTED` with `expire_time` in the past
        • `state` is `REGISTRATION_FAILED`
        • `state` is `TRANSFER_FAILED`

        When an active registration is successfully deleted, you can continue to use the domain in [Google Domains](https://domains.google/) until it expires. The calling user becomes the domain's sole owner in Google Domains, and permissions for the domain are subsequently managed there. The domain does not renew automatically unless the new owner sets up billing in Google Domains.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           DeleteRegistrationRequest request =
               DeleteRegistrationRequest.newBuilder()
                   .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           OperationFuture<Empty, OperationMetadata> future =
               domainsClient.deleteRegistrationOperationCallable().futureCall(request);
           // Do something.
           future.get();
         }
         
      • deleteRegistrationCallable

        public final com.google.api.gax.rpc.UnaryCallable<DeleteRegistrationRequest,​com.google.longrunning.Operation> deleteRegistrationCallable()
        Deletes a `Registration` resource.

        This method works on any `Registration` resource using [Subscription or Commitment billing](/domains/pricing#billing-models), provided that the resource was created at least 1 day in the past.

        For `Registration` resources using [Monthly billing](/domains/pricing#billing-models), this method works if:

        • `state` is `EXPORTED` with `expire_time` in the past
        • `state` is `REGISTRATION_FAILED`
        • `state` is `TRANSFER_FAILED`

        When an active registration is successfully deleted, you can continue to use the domain in [Google Domains](https://domains.google/) until it expires. The calling user becomes the domain's sole owner in Google Domains, and permissions for the domain are subsequently managed there. The domain does not renew automatically unless the new owner sets up billing in Google Domains.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           DeleteRegistrationRequest request =
               DeleteRegistrationRequest.newBuilder()
                   .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           ApiFuture<Operation> future = domainsClient.deleteRegistrationCallable().futureCall(request);
           // Do something.
           future.get();
         }
         
      • retrieveAuthorizationCode

        public final AuthorizationCode retrieveAuthorizationCode​(RegistrationName registration)
        Gets the authorization code of the `Registration` for the purpose of transferring the domain to another registrar.

        You can call this method only after 60 days have elapsed since the initial domain registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RegistrationName registration =
               RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
           AuthorizationCode response = domainsClient.retrieveAuthorizationCode(registration);
         }
         
        Parameters:
        registration - Required. The name of the `Registration` whose authorization code is being retrieved, in the format `projects/*/locations/*/registrations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • retrieveAuthorizationCode

        public final AuthorizationCode retrieveAuthorizationCode​(String registration)
        Gets the authorization code of the `Registration` for the purpose of transferring the domain to another registrar.

        You can call this method only after 60 days have elapsed since the initial domain registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String registration =
               RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString();
           AuthorizationCode response = domainsClient.retrieveAuthorizationCode(registration);
         }
         
        Parameters:
        registration - Required. The name of the `Registration` whose authorization code is being retrieved, in the format `projects/*/locations/*/registrations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • retrieveAuthorizationCode

        public final AuthorizationCode retrieveAuthorizationCode​(RetrieveAuthorizationCodeRequest request)
        Gets the authorization code of the `Registration` for the purpose of transferring the domain to another registrar.

        You can call this method only after 60 days have elapsed since the initial domain registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RetrieveAuthorizationCodeRequest request =
               RetrieveAuthorizationCodeRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           AuthorizationCode response = domainsClient.retrieveAuthorizationCode(request);
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • retrieveAuthorizationCodeCallable

        public final com.google.api.gax.rpc.UnaryCallable<RetrieveAuthorizationCodeRequest,​AuthorizationCode> retrieveAuthorizationCodeCallable()
        Gets the authorization code of the `Registration` for the purpose of transferring the domain to another registrar.

        You can call this method only after 60 days have elapsed since the initial domain registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RetrieveAuthorizationCodeRequest request =
               RetrieveAuthorizationCodeRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           ApiFuture<AuthorizationCode> future =
               domainsClient.retrieveAuthorizationCodeCallable().futureCall(request);
           // Do something.
           AuthorizationCode response = future.get();
         }
         
      • resetAuthorizationCode

        public final AuthorizationCode resetAuthorizationCode​(RegistrationName registration)
        Resets the authorization code of the `Registration` to a new random string.

        You can call this method only after 60 days have elapsed since the initial domain registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           RegistrationName registration =
               RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
           AuthorizationCode response = domainsClient.resetAuthorizationCode(registration);
         }
         
        Parameters:
        registration - Required. The name of the `Registration` whose authorization code is being reset, in the format `projects/*/locations/*/registrations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • resetAuthorizationCode

        public final AuthorizationCode resetAuthorizationCode​(String registration)
        Resets the authorization code of the `Registration` to a new random string.

        You can call this method only after 60 days have elapsed since the initial domain registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           String registration =
               RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString();
           AuthorizationCode response = domainsClient.resetAuthorizationCode(registration);
         }
         
        Parameters:
        registration - Required. The name of the `Registration` whose authorization code is being reset, in the format `projects/*/locations/*/registrations/*`.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • resetAuthorizationCode

        public final AuthorizationCode resetAuthorizationCode​(ResetAuthorizationCodeRequest request)
        Resets the authorization code of the `Registration` to a new random string.

        You can call this method only after 60 days have elapsed since the initial domain registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ResetAuthorizationCodeRequest request =
               ResetAuthorizationCodeRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           AuthorizationCode response = domainsClient.resetAuthorizationCode(request);
         }
         
        Parameters:
        request - The request object containing all of the parameters for the API call.
        Throws:
        com.google.api.gax.rpc.ApiException - if the remote call fails
      • resetAuthorizationCodeCallable

        public final com.google.api.gax.rpc.UnaryCallable<ResetAuthorizationCodeRequest,​AuthorizationCode> resetAuthorizationCodeCallable()
        Resets the authorization code of the `Registration` to a new random string.

        You can call this method only after 60 days have elapsed since the initial domain registration.

        Sample code:

        
         // This snippet has been automatically generated and should be regarded as a code template only.
         // It will require modifications to work:
         // - It may require correct/in-range values for request initialization.
         // - It may require specifying regional endpoints when creating the service client as shown in
         // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
         try (DomainsClient domainsClient = DomainsClient.create()) {
           ResetAuthorizationCodeRequest request =
               ResetAuthorizationCodeRequest.newBuilder()
                   .setRegistration(
                       RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
                   .build();
           ApiFuture<AuthorizationCode> future =
               domainsClient.resetAuthorizationCodeCallable().futureCall(request);
           // Do something.
           AuthorizationCode response = future.get();
         }
         
      • shutdown

        public void shutdown()
        Specified by:
        shutdown in interface com.google.api.gax.core.BackgroundResource
      • isShutdown

        public boolean isShutdown()
        Specified by:
        isShutdown in interface com.google.api.gax.core.BackgroundResource
      • isTerminated

        public boolean isTerminated()
        Specified by:
        isTerminated in interface com.google.api.gax.core.BackgroundResource
      • shutdownNow

        public void shutdownNow()
        Specified by:
        shutdownNow in interface com.google.api.gax.core.BackgroundResource