feat(dns/v1): add LRO helpers

Cloud DNS has a couple of LRO-type functions. Enabling the LRO wrappers
requires a few lines of hand-crafted code.

Note that the `librarian.yaml` file refers to the symbols without a package
name. That is needed because discovery-based services do not have a package
name. If you think: "But what about the Compute package further up in the
file?": for Compute we "infer" a package name from the service config yaml
file, but we have no such file for Cloud DNS.

With these changes I think the client library is ready to publish.

Author: coryan

Cargo.lock

@@ -645,13 +645,24 @@ libraries:
     rust:
       per_service_features: true
   - name: google-cloud-dns-v1
+    version: 1.0.0
     copyright_year: "2026"
-    skip_publish: true
+    keep:
+      - src/operation.rs
     specification_format: discovery
     rust:
+      package_dependencies:
+        - name: lro
+          package: google-cloud-lro
+          force_used: true
       roots:
         - discovery
         - googleapis
+      discovery:
+        operation_id: ..Operation
+        pollers:
+          - prefix: dns/v1/projects/{project}/managedZones/{managedZone}
+            method_id: ..managedZoneOperations.get
   - name: google-cloud-documentai-v1
     version: 1.5.0
     copyright_year: "2025"

librarian.yaml

@@ -44,6 +44,7 @@ bytes.workspace       = true
 gax.workspace         = true
 gaxi                  = { workspace = true, features = ["_internal-http-client"] }
 lazy_static.workspace = true
+lro.workspace         = true
 reqwest.workspace     = true
 serde.workspace       = true
 serde_json.workspace  = true

src/generated/cloud/dns/v1/Cargo.toml

@@ -1641,6 +1641,42 @@ pub mod managed_zones {
                 .map(gax::response::Response::into_body)
         }
 
+        /// Creates a [Poller][lro::Poller] to work with `patch`.
+        pub fn poller(self) -> impl lro::Poller<crate::model::Operation, crate::model::Operation> {
+            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
+            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
+
+            let stub = self.0.stub.clone();
+            let mut options = self.0.options.clone();
+            options.set_retry_policy(gax::retry_policy::NeverRetry);
+            let project = self.0.request.project.clone();
+            let managed_zone = self.0.request.managed_zone.clone();
+            let query = move |name| {
+                let stub = stub.clone();
+                let options = options.clone();
+                let project = project.clone();
+                let managed_zone = managed_zone.clone();
+                async {
+                    GetOperation::new(stub)
+                        .set_project(project)
+                        .set_managed_zone(managed_zone)
+                        .set_operation(name)
+                        .with_options(options)
+                        .send()
+                        .await
+                }
+            };
+
+            let start = move || async { self.send().await };
+
+            lro::internal::new_discovery_poller(
+                polling_error_policy,
+                polling_backoff_policy,
+                start,
+                query,
+            )
+        }
+
         /// Sets the value of [client_operation_id][crate::model::managed_zones::PatchRequest::client_operation_id].
         pub fn set_client_operation_id<T>(mut self, v: T) -> Self
         where
@@ -1910,6 +1946,42 @@ pub mod managed_zones {
                 .map(gax::response::Response::into_body)
         }
 
+        /// Creates a [Poller][lro::Poller] to work with `update`.
+        pub fn poller(self) -> impl lro::Poller<crate::model::Operation, crate::model::Operation> {
+            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
+            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
+
+            let stub = self.0.stub.clone();
+            let mut options = self.0.options.clone();
+            options.set_retry_policy(gax::retry_policy::NeverRetry);
+            let project = self.0.request.project.clone();
+            let managed_zone = self.0.request.managed_zone.clone();
+            let query = move |name| {
+                let stub = stub.clone();
+                let options = options.clone();
+                let project = project.clone();
+                let managed_zone = managed_zone.clone();
+                async {
+                    GetOperation::new(stub)
+                        .set_project(project)
+                        .set_managed_zone(managed_zone)
+                        .set_operation(name)
+                        .with_options(options)
+                        .send()
+                        .await
+                }
+            };
+
+            let start = move || async { self.send().await };
+
+            lro::internal::new_discovery_poller(
+                polling_error_policy,
+                polling_backoff_policy,
+                start,
+                query,
+            )
+        }
+
         /// Sets the value of [client_operation_id][crate::model::managed_zones::UpdateRequest::client_operation_id].
         pub fn set_client_operation_id<T>(mut self, v: T) -> Self
         where
@@ -1965,6 +2037,99 @@ pub mod managed_zones {
             &mut self.0.options
         }
     }
+
+    /// The request builder for [ManagedZones::get_operation][crate::client::ManagedZones::get_operation] calls.
+    ///
+    /// # Example
+    /// ```
+    /// # use google_cloud_dns_v1::builder::managed_zones::GetOperation;
+    /// # async fn sample() -> gax::Result<()> {
+    ///
+    /// let builder = prepare_request_builder();
+    /// let response = builder.send().await?;
+    /// # Ok(()) }
+    ///
+    /// fn prepare_request_builder() -> GetOperation {
+    ///   # panic!();
+    ///   // ... details omitted ...
+    /// }
+    /// ```
+    #[derive(Clone, Debug)]
+    pub struct GetOperation(RequestBuilder<crate::model::managed_zone_operations::GetRequest>);
+
+    impl GetOperation {
+        pub(crate) fn new(
+            stub: std::sync::Arc<dyn super::super::stub::dynamic::ManagedZones>,
+        ) -> Self {
+            Self(RequestBuilder::new(stub))
+        }
+
+        /// Sets the full request, replacing any prior values.
+        pub fn with_request<V: Into<crate::model::managed_zone_operations::GetRequest>>(
+            mut self,
+            v: V,
+        ) -> Self {
+            self.0.request = v.into();
+            self
+        }
+
+        /// Sets all the options, replacing any prior values.
+        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
+            self.0.options = v.into();
+            self
+        }
+
+        /// Sends the request.
+        pub async fn send(self) -> Result<crate::model::Operation> {
+            (*self.0.stub)
+                .get_operation(self.0.request, self.0.options)
+                .await
+                .map(gax::response::Response::into_body)
+        }
+
+        /// Sets the value of [client_operation_id][crate::model::managed_zone_operations::GetRequest::client_operation_id].
+        pub fn set_client_operation_id<T>(mut self, v: T) -> Self
+        where
+            T: std::convert::Into<std::string::String>,
+        {
+            self.0.request.client_operation_id = std::option::Option::Some(v.into());
+            self
+        }
+
+        /// Sets or clears the value of [client_operation_id][crate::model::managed_zone_operations::GetRequest::client_operation_id].
+        pub fn set_or_clear_client_operation_id<T>(mut self, v: std::option::Option<T>) -> Self
+        where
+            T: std::convert::Into<std::string::String>,
+        {
+            self.0.request.client_operation_id = v.map(|x| x.into());
+            self
+        }
+
+        /// Sets the value of [managed_zone][crate::model::managed_zone_operations::GetRequest::managed_zone].
+        pub fn set_managed_zone<T: Into<std::string::String>>(mut self, v: T) -> Self {
+            self.0.request.managed_zone = v.into();
+            self
+        }
+
+        /// Sets the value of [operation][crate::model::managed_zone_operations::GetRequest::operation].
+        pub fn set_operation<T: Into<std::string::String>>(mut self, v: T) -> Self {
+            self.0.request.operation = v.into();
+            self
+        }
+
+        /// Sets the value of [project][crate::model::managed_zone_operations::GetRequest::project].
+        pub fn set_project<T: Into<std::string::String>>(mut self, v: T) -> Self {
+            self.0.request.project = v.into();
+            self
+        }
+    }
+
+    #[doc(hidden)]
+    impl gax::options::internal::RequestBuilder for GetOperation {
+        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
+            &mut self.0.options
+        }
+    }
 }
 
 pub mod policies {

src/generated/cloud/dns/v1/src/builder.rs

@@ -509,6 +509,11 @@ impl ManagedZones {
     pub fn update(&self) -> super::builder::managed_zones::Update {
         super::builder::managed_zones::Update::new(self.inner.clone())
     }
+
+    /// Fetches the representation of an existing Operation.
+    pub fn get_operation(&self) -> super::builder::managed_zones::GetOperation {
+        super::builder::managed_zones::GetOperation::new(self.inner.clone())
+    }
 }
 
 /// Implements a client for the Cloud DNS API.

src/generated/cloud/dns/v1/src/client.rs

@@ -90,3 +90,5 @@ pub(crate) mod info {
         };
     }
 }
+
+pub mod operation;

src/generated/cloud/dns/v1/src/lib.rs

@@ -22,6 +22,7 @@ extern crate bytes;
 extern crate gax;
 extern crate gaxi;
 extern crate lazy_static;
+extern crate lro;
 extern crate reqwest;
 extern crate serde;
 extern crate serde_json;

src/generated/cloud/dns/v1/src/model.rs

@@ -0,0 +1,24 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::model::Operation;
+
+impl lro::internal::DiscoveryOperation for Operation {
+    fn name(&self) -> Option<&String> {
+        self.id.as_ref()
+    }
+    fn done(&self) -> bool {
+        self.status == Some(crate::model::operation::Status::Done)
+    }
+}

src/generated/cloud/dns/v1/src/operation.rs

@@ -254,6 +254,39 @@ pub trait ManagedZones: std::fmt::Debug + Send + Sync {
     > + Send {
         gaxi::unimplemented::unimplemented_stub()
     }
+
+    /// Implements [super::client::ManagedZones::get_operation].
+    fn get_operation(
+        &self,
+        _req: crate::model::managed_zone_operations::GetRequest,
+        _options: gax::options::RequestOptions,
+    ) -> impl std::future::Future<
+        Output = crate::Result<gax::response::Response<crate::model::Operation>>,
+    > + Send {
+        gaxi::unimplemented::unimplemented_stub()
+    }
+
+    /// Returns the polling error policy.
+    ///
+    /// When mocking, this method is typically irrelevant. Do not try to verify
+    /// it is called by your mocks.
+    fn get_polling_error_policy(
+        &self,
+        _options: &gax::options::RequestOptions,
+    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
+        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
+    }
+
+    /// Returns the polling backoff policy.
+    ///
+    /// When mocking, this method is typically irrelevant. Do not try to verify
+    /// it is called by your mocks.
+    fn get_polling_backoff_policy(
+        &self,
+        _options: &gax::options::RequestOptions,
+    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
+        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
+    }
 }
 
 /// Defines the trait used to implement [super::client::Policies].

src/generated/cloud/dns/v1/src/stub.rs

@@ -200,6 +200,22 @@ pub trait ManagedZones: std::fmt::Debug + Send + Sync {
         req: crate::model::managed_zones::UpdateRequest,
         options: gax::options::RequestOptions,
     ) -> crate::Result<gax::response::Response<crate::model::Operation>>;
+
+    async fn get_operation(
+        &self,
+        req: crate::model::managed_zone_operations::GetRequest,
+        options: gax::options::RequestOptions,
+    ) -> crate::Result<gax::response::Response<crate::model::Operation>>;
+
+    fn get_polling_error_policy(
+        &self,
+        options: &gax::options::RequestOptions,
+    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy>;
+
+    fn get_polling_backoff_policy(
+        &self,
+        options: &gax::options::RequestOptions,
+    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy>;
 }
 
 /// All implementations of [super::ManagedZones] also implement [ManagedZones].
@@ -286,6 +302,29 @@ impl<T: super::ManagedZones> ManagedZones for T {
     ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
         T::update(self, req, options).await
     }
+
+    /// Forwards the call to the implementation provided by `T`.
+    async fn get_operation(
+        &self,
+        req: crate::model::managed_zone_operations::GetRequest,
+        options: gax::options::RequestOptions,
+    ) -> crate::Result<gax::response::Response<crate::model::Operation>> {
+        T::get_operation(self, req, options).await
+    }
+
+    fn get_polling_error_policy(
+        &self,
+        options: &gax::options::RequestOptions,
+    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
+        T::get_polling_error_policy(self, options)
+    }
+
+    fn get_polling_backoff_policy(
+        &self,
+        options: &gax::options::RequestOptions,
+    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
+        T::get_polling_backoff_policy(self, options)
+    }
 }
 
 /// A dyn-compatible, crate-private version of [super::Policies].