apache-airflow-providers-google 8.12.0rc1__py3-none-any.whl → 9.0.0rc2__py3-none-any.whl

airflow/providers/google_vendor/googleads/v12/services/services/google_ads_service/client.py

@@ -0,0 +1,3662 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 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
+#
+#     http://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.
+#
+from collections import OrderedDict
+import os
+import re
+from typing import Dict, Iterable, Optional, Sequence, Tuple, Type, Union
+import pkg_resources
+
+from google.api_core import client_options as client_options_lib
+from google.api_core import gapic_v1
+from google.api_core import retry as retries
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.auth.transport import mtls  # type: ignore
+from google.auth.transport.grpc import SslCredentials  # type: ignore
+from google.auth.exceptions import MutualTLSChannelError  # type: ignore
+from google.oauth2 import service_account  # type: ignore
+
+try:
+    OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault]
+except AttributeError:  # pragma: NO COVER
+    OptionalRetry = Union[retries.Retry, object]  # type: ignore
+
+from airflow.providers.google_vendor.googleads.v12.services.services.google_ads_service import pagers
+from airflow.providers.google_vendor.googleads.v12.services.types import google_ads_service
+from google.protobuf import field_mask_pb2  # type: ignore
+from google.rpc import status_pb2  # type: ignore
+from .transports.base import GoogleAdsServiceTransport, DEFAULT_CLIENT_INFO
+from .transports.grpc import GoogleAdsServiceGrpcTransport
+
+
+class GoogleAdsServiceClientMeta(type):
+    """Metaclass for the GoogleAdsService client.
+
+    This provides class-level methods for building and retrieving
+    support objects (e.g. transport) without polluting the client instance
+    objects.
+    """
+
+    _transport_registry = (
+        OrderedDict()
+    )  # type: Dict[str, Type[GoogleAdsServiceTransport]]
+    _transport_registry["grpc"] = GoogleAdsServiceGrpcTransport
+
+    def get_transport_class(
+        cls, label: str = None,
+    ) -> Type[GoogleAdsServiceTransport]:
+        """Returns an appropriate transport class.
+
+        Args:
+            label: The name of the desired transport. If none is
+                provided, then the first transport in the registry is used.
+
+        Returns:
+            The transport class to use.
+        """
+        # If a specific transport is requested, return that one.
+        if label:
+            return cls._transport_registry[label]
+
+        # No transport is requested; return the default (that is, the first one
+        # in the dictionary).
+        return next(iter(cls._transport_registry.values()))
+
+
+class GoogleAdsServiceClient(metaclass=GoogleAdsServiceClientMeta):
+    """Service to fetch data and metrics across resources."""
+
+    @staticmethod
+    def _get_default_mtls_endpoint(api_endpoint):
+        """Converts api endpoint to mTLS endpoint.
+
+        Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to
+        "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively.
+        Args:
+            api_endpoint (Optional[str]): the api endpoint to convert.
+        Returns:
+            str: converted mTLS api endpoint.
+        """
+        if not api_endpoint:
+            return api_endpoint
+
+        mtls_endpoint_re = re.compile(
+            r"(?P<name>[^.]+)(?P<mtls>\.mtls)?(?P<sandbox>\.sandbox)?(?P<googledomain>\.googleapis\.com)?"
+        )
+
+        m = mtls_endpoint_re.match(api_endpoint)
+        name, mtls, sandbox, googledomain = m.groups()
+        if mtls or not googledomain:
+            return api_endpoint
+
+        if sandbox:
+            return api_endpoint.replace(
+                "sandbox.googleapis.com", "mtls.sandbox.googleapis.com"
+            )
+
+        return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com")
+
+    DEFAULT_ENDPOINT = "googleads.googleapis.com"
+    DEFAULT_MTLS_ENDPOINT = _get_default_mtls_endpoint.__func__(  # type: ignore
+        DEFAULT_ENDPOINT
+    )
+
+    @classmethod
+    def from_service_account_info(cls, info: dict, *args, **kwargs):
+        """Creates an instance of this client using the provided credentials
+            info.
+
+        Args:
+            info (dict): The service account private key info.
+            args: Additional arguments to pass to the constructor.
+            kwargs: Additional arguments to pass to the constructor.
+
+        Returns:
+            GoogleAdsServiceClient: The constructed client.
+        """
+        credentials = service_account.Credentials.from_service_account_info(
+            info
+        )
+        kwargs["credentials"] = credentials
+        return cls(*args, **kwargs)
+
+    @classmethod
+    def from_service_account_file(cls, filename: str, *args, **kwargs):
+        """Creates an instance of this client using the provided credentials
+        file.
+
+        Args:
+            filename (str): The path to the service account private key json
+                file.
+            args: Additional arguments to pass to the constructor.
+            kwargs: Additional arguments to pass to the constructor.
+
+        Returns:
+            GoogleAdsServiceClient: The constructed client.
+        """
+        credentials = service_account.Credentials.from_service_account_file(
+            filename
+        )
+        kwargs["credentials"] = credentials
+        return cls(*args, **kwargs)
+
+    from_service_account_json = from_service_account_file
+
+    @property
+    def transport(self) -> GoogleAdsServiceTransport:
+        """Returns the transport used by the client instance.
+
+        Returns:
+            GoogleAdsServiceTransport: The transport used by the client
+                instance.
+        """
+        return self._transport
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        """Releases underlying transport's resources.
+
+        .. warning::
+            ONLY use as a context manager if the transport is NOT shared
+            with other clients! Exiting the with block will CLOSE the transport
+            and may cause errors in other clients!
+        """
+        self.transport.close()
+
+    @staticmethod
+    def accessible_bidding_strategy_path(
+        customer_id: str, bidding_strategy_id: str,
+    ) -> str:
+        """Returns a fully-qualified accessible_bidding_strategy string."""
+        return "customers/{customer_id}/accessibleBiddingStrategies/{bidding_strategy_id}".format(
+            customer_id=customer_id, bidding_strategy_id=bidding_strategy_id,
+        )
+
+    @staticmethod
+    def parse_accessible_bidding_strategy_path(path: str) -> Dict[str, str]:
+        """Parses a accessible_bidding_strategy path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/accessibleBiddingStrategies/(?P<bidding_strategy_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def account_budget_path(customer_id: str, account_budget_id: str,) -> str:
+        """Returns a fully-qualified account_budget string."""
+        return "customers/{customer_id}/accountBudgets/{account_budget_id}".format(
+            customer_id=customer_id, account_budget_id=account_budget_id,
+        )
+
+    @staticmethod
+    def parse_account_budget_path(path: str) -> Dict[str, str]:
+        """Parses a account_budget path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/accountBudgets/(?P<account_budget_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def account_budget_proposal_path(
+        customer_id: str, account_budget_proposal_id: str,
+    ) -> str:
+        """Returns a fully-qualified account_budget_proposal string."""
+        return "customers/{customer_id}/accountBudgetProposals/{account_budget_proposal_id}".format(
+            customer_id=customer_id,
+            account_budget_proposal_id=account_budget_proposal_id,
+        )
+
+    @staticmethod
+    def parse_account_budget_proposal_path(path: str) -> Dict[str, str]:
+        """Parses a account_budget_proposal path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/accountBudgetProposals/(?P<account_budget_proposal_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def account_link_path(customer_id: str, account_link_id: str,) -> str:
+        """Returns a fully-qualified account_link string."""
+        return "customers/{customer_id}/accountLinks/{account_link_id}".format(
+            customer_id=customer_id, account_link_id=account_link_id,
+        )
+
+    @staticmethod
+    def parse_account_link_path(path: str) -> Dict[str, str]:
+        """Parses a account_link path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/accountLinks/(?P<account_link_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_path(customer_id: str, ad_id: str,) -> str:
+        """Returns a fully-qualified ad string."""
+        return "customers/{customer_id}/ads/{ad_id}".format(
+            customer_id=customer_id, ad_id=ad_id,
+        )
+
+    @staticmethod
+    def parse_ad_path(path: str) -> Dict[str, str]:
+        """Parses a ad path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/ads/(?P<ad_id>.+?)$", path
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_path(customer_id: str, ad_group_id: str,) -> str:
+        """Returns a fully-qualified ad_group string."""
+        return "customers/{customer_id}/adGroups/{ad_group_id}".format(
+            customer_id=customer_id, ad_group_id=ad_group_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroups/(?P<ad_group_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_ad_path(
+        customer_id: str, ad_group_id: str, ad_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_ad string."""
+        return "customers/{customer_id}/adGroupAds/{ad_group_id}~{ad_id}".format(
+            customer_id=customer_id, ad_group_id=ad_group_id, ad_id=ad_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_ad_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_ad path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupAds/(?P<ad_group_id>.+?)~(?P<ad_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_ad_asset_combination_view_path(
+        customer_id: str,
+        ad_group_id: str,
+        ad_id: str,
+        asset_combination_id_low: str,
+        asset_combination_id_high: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_ad_asset_combination_view string."""
+        return "customers/{customer_id}/adGroupAdAssetCombinationViews/{ad_group_id}~{ad_id}~{asset_combination_id_low}~{asset_combination_id_high}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            ad_id=ad_id,
+            asset_combination_id_low=asset_combination_id_low,
+            asset_combination_id_high=asset_combination_id_high,
+        )
+
+    @staticmethod
+    def parse_ad_group_ad_asset_combination_view_path(
+        path: str,
+    ) -> Dict[str, str]:
+        """Parses a ad_group_ad_asset_combination_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupAdAssetCombinationViews/(?P<ad_group_id>.+?)~(?P<ad_id>.+?)~(?P<asset_combination_id_low>.+?)~(?P<asset_combination_id_high>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_ad_asset_view_path(
+        customer_id: str,
+        ad_group_id: str,
+        ad_id: str,
+        asset_id: str,
+        field_type: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_ad_asset_view string."""
+        return "customers/{customer_id}/adGroupAdAssetViews/{ad_group_id}~{ad_id}~{asset_id}~{field_type}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            ad_id=ad_id,
+            asset_id=asset_id,
+            field_type=field_type,
+        )
+
+    @staticmethod
+    def parse_ad_group_ad_asset_view_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_ad_asset_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupAdAssetViews/(?P<ad_group_id>.+?)~(?P<ad_id>.+?)~(?P<asset_id>.+?)~(?P<field_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_ad_label_path(
+        customer_id: str, ad_group_id: str, ad_id: str, label_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_ad_label string."""
+        return "customers/{customer_id}/adGroupAdLabels/{ad_group_id}~{ad_id}~{label_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            ad_id=ad_id,
+            label_id=label_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_ad_label_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_ad_label path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupAdLabels/(?P<ad_group_id>.+?)~(?P<ad_id>.+?)~(?P<label_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_asset_path(
+        customer_id: str, ad_group_id: str, asset_id: str, field_type: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_asset string."""
+        return "customers/{customer_id}/adGroupAssets/{ad_group_id}~{asset_id}~{field_type}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            asset_id=asset_id,
+            field_type=field_type,
+        )
+
+    @staticmethod
+    def parse_ad_group_asset_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_asset path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupAssets/(?P<ad_group_id>.+?)~(?P<asset_id>.+?)~(?P<field_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_asset_set_path(
+        customer_id: str, ad_group_id: str, asset_set_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_asset_set string."""
+        return "customers/{customer_id}/adGroupAssetSets/{ad_group_id}~{asset_set_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            asset_set_id=asset_set_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_asset_set_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_asset_set path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupAssetSets/(?P<ad_group_id>.+?)~(?P<asset_set_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_audience_view_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_audience_view string."""
+        return "customers/{customer_id}/adGroupAudienceViews/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_audience_view_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_audience_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupAudienceViews/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_bid_modifier_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_bid_modifier string."""
+        return "customers/{customer_id}/adGroupBidModifiers/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_bid_modifier_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_bid_modifier path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupBidModifiers/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_criterion_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_criterion string."""
+        return "customers/{customer_id}/adGroupCriteria/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_criterion_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_criterion path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupCriteria/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_criterion_customizer_path(
+        customer_id: str,
+        ad_group_id: str,
+        criterion_id: str,
+        customizer_attribute_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_criterion_customizer string."""
+        return "customers/{customer_id}/adGroupCriterionCustomizers/{ad_group_id}~{criterion_id}~{customizer_attribute_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+            customizer_attribute_id=customizer_attribute_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_criterion_customizer_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_criterion_customizer path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupCriterionCustomizers/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)~(?P<customizer_attribute_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_criterion_label_path(
+        customer_id: str, ad_group_id: str, criterion_id: str, label_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_criterion_label string."""
+        return "customers/{customer_id}/adGroupCriterionLabels/{ad_group_id}~{criterion_id}~{label_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+            label_id=label_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_criterion_label_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_criterion_label path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupCriterionLabels/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)~(?P<label_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_criterion_simulation_path(
+        customer_id: str,
+        ad_group_id: str,
+        criterion_id: str,
+        type: str,
+        modification_method: str,
+        start_date: str,
+        end_date: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_criterion_simulation string."""
+        return "customers/{customer_id}/adGroupCriterionSimulations/{ad_group_id}~{criterion_id}~{type}~{modification_method}~{start_date}~{end_date}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+            type=type,
+            modification_method=modification_method,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    @staticmethod
+    def parse_ad_group_criterion_simulation_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_criterion_simulation path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupCriterionSimulations/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)~(?P<type>.+?)~(?P<modification_method>.+?)~(?P<start_date>.+?)~(?P<end_date>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_customizer_path(
+        customer_id: str, ad_group_id: str, customizer_attribute_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_customizer string."""
+        return "customers/{customer_id}/adGroupCustomizers/{ad_group_id}~{customizer_attribute_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            customizer_attribute_id=customizer_attribute_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_customizer_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_customizer path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupCustomizers/(?P<ad_group_id>.+?)~(?P<customizer_attribute_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_extension_setting_path(
+        customer_id: str, ad_group_id: str, extension_type: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_extension_setting string."""
+        return "customers/{customer_id}/adGroupExtensionSettings/{ad_group_id}~{extension_type}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            extension_type=extension_type,
+        )
+
+    @staticmethod
+    def parse_ad_group_extension_setting_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_extension_setting path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupExtensionSettings/(?P<ad_group_id>.+?)~(?P<extension_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_feed_path(
+        customer_id: str, ad_group_id: str, feed_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_feed string."""
+        return "customers/{customer_id}/adGroupFeeds/{ad_group_id}~{feed_id}".format(
+            customer_id=customer_id, ad_group_id=ad_group_id, feed_id=feed_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_feed_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_feed path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupFeeds/(?P<ad_group_id>.+?)~(?P<feed_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_label_path(
+        customer_id: str, ad_group_id: str, label_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_label string."""
+        return "customers/{customer_id}/adGroupLabels/{ad_group_id}~{label_id}".format(
+            customer_id=customer_id, ad_group_id=ad_group_id, label_id=label_id,
+        )
+
+    @staticmethod
+    def parse_ad_group_label_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_label path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupLabels/(?P<ad_group_id>.+?)~(?P<label_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_group_simulation_path(
+        customer_id: str,
+        ad_group_id: str,
+        type: str,
+        modification_method: str,
+        start_date: str,
+        end_date: str,
+    ) -> str:
+        """Returns a fully-qualified ad_group_simulation string."""
+        return "customers/{customer_id}/adGroupSimulations/{ad_group_id}~{type}~{modification_method}~{start_date}~{end_date}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            type=type,
+            modification_method=modification_method,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    @staticmethod
+    def parse_ad_group_simulation_path(path: str) -> Dict[str, str]:
+        """Parses a ad_group_simulation path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adGroupSimulations/(?P<ad_group_id>.+?)~(?P<type>.+?)~(?P<modification_method>.+?)~(?P<start_date>.+?)~(?P<end_date>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_parameter_path(
+        customer_id: str,
+        ad_group_id: str,
+        criterion_id: str,
+        parameter_index: str,
+    ) -> str:
+        """Returns a fully-qualified ad_parameter string."""
+        return "customers/{customer_id}/adParameters/{ad_group_id}~{criterion_id}~{parameter_index}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+            parameter_index=parameter_index,
+        )
+
+    @staticmethod
+    def parse_ad_parameter_path(path: str) -> Dict[str, str]:
+        """Parses a ad_parameter path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adParameters/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)~(?P<parameter_index>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def ad_schedule_view_path(
+        customer_id: str, campaign_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified ad_schedule_view string."""
+        return "customers/{customer_id}/adScheduleViews/{campaign_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_ad_schedule_view_path(path: str) -> Dict[str, str]:
+        """Parses a ad_schedule_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/adScheduleViews/(?P<campaign_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def age_range_view_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified age_range_view string."""
+        return "customers/{customer_id}/ageRangeViews/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_age_range_view_path(path: str) -> Dict[str, str]:
+        """Parses a age_range_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/ageRangeViews/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def asset_path(customer_id: str, asset_id: str,) -> str:
+        """Returns a fully-qualified asset string."""
+        return "customers/{customer_id}/assets/{asset_id}".format(
+            customer_id=customer_id, asset_id=asset_id,
+        )
+
+    @staticmethod
+    def parse_asset_path(path: str) -> Dict[str, str]:
+        """Parses a asset path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/assets/(?P<asset_id>.+?)$", path
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def asset_field_type_view_path(customer_id: str, field_type: str,) -> str:
+        """Returns a fully-qualified asset_field_type_view string."""
+        return "customers/{customer_id}/assetFieldTypeViews/{field_type}".format(
+            customer_id=customer_id, field_type=field_type,
+        )
+
+    @staticmethod
+    def parse_asset_field_type_view_path(path: str) -> Dict[str, str]:
+        """Parses a asset_field_type_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/assetFieldTypeViews/(?P<field_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def asset_group_path(customer_id: str, asset_group_id: str,) -> str:
+        """Returns a fully-qualified asset_group string."""
+        return "customers/{customer_id}/assetGroups/{asset_group_id}".format(
+            customer_id=customer_id, asset_group_id=asset_group_id,
+        )
+
+    @staticmethod
+    def parse_asset_group_path(path: str) -> Dict[str, str]:
+        """Parses a asset_group path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/assetGroups/(?P<asset_group_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def asset_group_asset_path(
+        customer_id: str, asset_group_id: str, asset_id: str, field_type: str,
+    ) -> str:
+        """Returns a fully-qualified asset_group_asset string."""
+        return "customers/{customer_id}/assetGroupAssets/{asset_group_id}~{asset_id}~{field_type}".format(
+            customer_id=customer_id,
+            asset_group_id=asset_group_id,
+            asset_id=asset_id,
+            field_type=field_type,
+        )
+
+    @staticmethod
+    def parse_asset_group_asset_path(path: str) -> Dict[str, str]:
+        """Parses a asset_group_asset path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/assetGroupAssets/(?P<asset_group_id>.+?)~(?P<asset_id>.+?)~(?P<field_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def asset_group_listing_group_filter_path(
+        customer_id: str, asset_group_id: str, listing_group_filter_id: str,
+    ) -> str:
+        """Returns a fully-qualified asset_group_listing_group_filter string."""
+        return "customers/{customer_id}/assetGroupListingGroupFilters/{asset_group_id}~{listing_group_filter_id}".format(
+            customer_id=customer_id,
+            asset_group_id=asset_group_id,
+            listing_group_filter_id=listing_group_filter_id,
+        )
+
+    @staticmethod
+    def parse_asset_group_listing_group_filter_path(
+        path: str,
+    ) -> Dict[str, str]:
+        """Parses a asset_group_listing_group_filter path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/assetGroupListingGroupFilters/(?P<asset_group_id>.+?)~(?P<listing_group_filter_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def asset_group_product_group_view_path(
+        customer_id: str, asset_group_id: str, listing_group_filter_id: str,
+    ) -> str:
+        """Returns a fully-qualified asset_group_product_group_view string."""
+        return "customers/{customer_id}/assetGroupProductGroupViews/{asset_group_id}~{listing_group_filter_id}".format(
+            customer_id=customer_id,
+            asset_group_id=asset_group_id,
+            listing_group_filter_id=listing_group_filter_id,
+        )
+
+    @staticmethod
+    def parse_asset_group_product_group_view_path(path: str) -> Dict[str, str]:
+        """Parses a asset_group_product_group_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/assetGroupProductGroupViews/(?P<asset_group_id>.+?)~(?P<listing_group_filter_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def asset_group_signal_path(
+        customer_id: str, asset_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified asset_group_signal string."""
+        return "customers/{customer_id}/assetGroupSignals/{asset_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            asset_group_id=asset_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_asset_group_signal_path(path: str) -> Dict[str, str]:
+        """Parses a asset_group_signal path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/assetGroupSignals/(?P<asset_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def asset_set_path(customer_id: str, asset_set_id: str,) -> str:
+        """Returns a fully-qualified asset_set string."""
+        return "customers/{customer_id}/assetSets/{asset_set_id}".format(
+            customer_id=customer_id, asset_set_id=asset_set_id,
+        )
+
+    @staticmethod
+    def parse_asset_set_path(path: str) -> Dict[str, str]:
+        """Parses a asset_set path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/assetSets/(?P<asset_set_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def asset_set_asset_path(
+        customer_id: str, asset_set_id: str, asset_id: str,
+    ) -> str:
+        """Returns a fully-qualified asset_set_asset string."""
+        return "customers/{customer_id}/assetSetAssets/{asset_set_id}~{asset_id}".format(
+            customer_id=customer_id,
+            asset_set_id=asset_set_id,
+            asset_id=asset_id,
+        )
+
+    @staticmethod
+    def parse_asset_set_asset_path(path: str) -> Dict[str, str]:
+        """Parses a asset_set_asset path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/assetSetAssets/(?P<asset_set_id>.+?)~(?P<asset_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def asset_set_type_view_path(customer_id: str, asset_set_type: str,) -> str:
+        """Returns a fully-qualified asset_set_type_view string."""
+        return "customers/{customer_id}/assetSetTypeViews/{asset_set_type}".format(
+            customer_id=customer_id, asset_set_type=asset_set_type,
+        )
+
+    @staticmethod
+    def parse_asset_set_type_view_path(path: str) -> Dict[str, str]:
+        """Parses a asset_set_type_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/assetSetTypeViews/(?P<asset_set_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def audience_path(customer_id: str, audience_id: str,) -> str:
+        """Returns a fully-qualified audience string."""
+        return "customers/{customer_id}/audiences/{audience_id}".format(
+            customer_id=customer_id, audience_id=audience_id,
+        )
+
+    @staticmethod
+    def parse_audience_path(path: str) -> Dict[str, str]:
+        """Parses a audience path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/audiences/(?P<audience_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def batch_job_path(customer_id: str, batch_job_id: str,) -> str:
+        """Returns a fully-qualified batch_job string."""
+        return "customers/{customer_id}/batchJobs/{batch_job_id}".format(
+            customer_id=customer_id, batch_job_id=batch_job_id,
+        )
+
+    @staticmethod
+    def parse_batch_job_path(path: str) -> Dict[str, str]:
+        """Parses a batch_job path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/batchJobs/(?P<batch_job_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def bidding_data_exclusion_path(
+        customer_id: str, seasonality_event_id: str,
+    ) -> str:
+        """Returns a fully-qualified bidding_data_exclusion string."""
+        return "customers/{customer_id}/biddingDataExclusions/{seasonality_event_id}".format(
+            customer_id=customer_id, seasonality_event_id=seasonality_event_id,
+        )
+
+    @staticmethod
+    def parse_bidding_data_exclusion_path(path: str) -> Dict[str, str]:
+        """Parses a bidding_data_exclusion path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/biddingDataExclusions/(?P<seasonality_event_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def bidding_seasonality_adjustment_path(
+        customer_id: str, seasonality_event_id: str,
+    ) -> str:
+        """Returns a fully-qualified bidding_seasonality_adjustment string."""
+        return "customers/{customer_id}/biddingSeasonalityAdjustments/{seasonality_event_id}".format(
+            customer_id=customer_id, seasonality_event_id=seasonality_event_id,
+        )
+
+    @staticmethod
+    def parse_bidding_seasonality_adjustment_path(path: str) -> Dict[str, str]:
+        """Parses a bidding_seasonality_adjustment path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/biddingSeasonalityAdjustments/(?P<seasonality_event_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def bidding_strategy_path(
+        customer_id: str, bidding_strategy_id: str,
+    ) -> str:
+        """Returns a fully-qualified bidding_strategy string."""
+        return "customers/{customer_id}/biddingStrategies/{bidding_strategy_id}".format(
+            customer_id=customer_id, bidding_strategy_id=bidding_strategy_id,
+        )
+
+    @staticmethod
+    def parse_bidding_strategy_path(path: str) -> Dict[str, str]:
+        """Parses a bidding_strategy path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/biddingStrategies/(?P<bidding_strategy_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def bidding_strategy_simulation_path(
+        customer_id: str,
+        bidding_strategy_id: str,
+        type: str,
+        modification_method: str,
+        start_date: str,
+        end_date: str,
+    ) -> str:
+        """Returns a fully-qualified bidding_strategy_simulation string."""
+        return "customers/{customer_id}/biddingStrategySimulations/{bidding_strategy_id}~{type}~{modification_method}~{start_date}~{end_date}".format(
+            customer_id=customer_id,
+            bidding_strategy_id=bidding_strategy_id,
+            type=type,
+            modification_method=modification_method,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    @staticmethod
+    def parse_bidding_strategy_simulation_path(path: str) -> Dict[str, str]:
+        """Parses a bidding_strategy_simulation path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/biddingStrategySimulations/(?P<bidding_strategy_id>.+?)~(?P<type>.+?)~(?P<modification_method>.+?)~(?P<start_date>.+?)~(?P<end_date>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def billing_setup_path(customer_id: str, billing_setup_id: str,) -> str:
+        """Returns a fully-qualified billing_setup string."""
+        return "customers/{customer_id}/billingSetups/{billing_setup_id}".format(
+            customer_id=customer_id, billing_setup_id=billing_setup_id,
+        )
+
+    @staticmethod
+    def parse_billing_setup_path(path: str) -> Dict[str, str]:
+        """Parses a billing_setup path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/billingSetups/(?P<billing_setup_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def call_view_path(customer_id: str, call_detail_id: str,) -> str:
+        """Returns a fully-qualified call_view string."""
+        return "customers/{customer_id}/callViews/{call_detail_id}".format(
+            customer_id=customer_id, call_detail_id=call_detail_id,
+        )
+
+    @staticmethod
+    def parse_call_view_path(path: str) -> Dict[str, str]:
+        """Parses a call_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/callViews/(?P<call_detail_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_path(customer_id: str, campaign_id: str,) -> str:
+        """Returns a fully-qualified campaign string."""
+        return "customers/{customer_id}/campaigns/{campaign_id}".format(
+            customer_id=customer_id, campaign_id=campaign_id,
+        )
+
+    @staticmethod
+    def parse_campaign_path(path: str) -> Dict[str, str]:
+        """Parses a campaign path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaigns/(?P<campaign_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_asset_path(
+        customer_id: str, campaign_id: str, asset_id: str, field_type: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_asset string."""
+        return "customers/{customer_id}/campaignAssets/{campaign_id}~{asset_id}~{field_type}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            asset_id=asset_id,
+            field_type=field_type,
+        )
+
+    @staticmethod
+    def parse_campaign_asset_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_asset path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignAssets/(?P<campaign_id>.+?)~(?P<asset_id>.+?)~(?P<field_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_asset_set_path(
+        customer_id: str, campaign_id: str, asset_set_id: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_asset_set string."""
+        return "customers/{customer_id}/campaignAssetSets/{campaign_id}~{asset_set_id}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            asset_set_id=asset_set_id,
+        )
+
+    @staticmethod
+    def parse_campaign_asset_set_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_asset_set path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignAssetSets/(?P<campaign_id>.+?)~(?P<asset_set_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_audience_view_path(
+        customer_id: str, campaign_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_audience_view string."""
+        return "customers/{customer_id}/campaignAudienceViews/{campaign_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_campaign_audience_view_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_audience_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignAudienceViews/(?P<campaign_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_bid_modifier_path(
+        customer_id: str, campaign_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_bid_modifier string."""
+        return "customers/{customer_id}/campaignBidModifiers/{campaign_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_campaign_bid_modifier_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_bid_modifier path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignBidModifiers/(?P<campaign_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_budget_path(customer_id: str, campaign_budget_id: str,) -> str:
+        """Returns a fully-qualified campaign_budget string."""
+        return "customers/{customer_id}/campaignBudgets/{campaign_budget_id}".format(
+            customer_id=customer_id, campaign_budget_id=campaign_budget_id,
+        )
+
+    @staticmethod
+    def parse_campaign_budget_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_budget path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignBudgets/(?P<campaign_budget_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_conversion_goal_path(
+        customer_id: str, campaign_id: str, category: str, source: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_conversion_goal string."""
+        return "customers/{customer_id}/campaignConversionGoals/{campaign_id}~{category}~{source}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            category=category,
+            source=source,
+        )
+
+    @staticmethod
+    def parse_campaign_conversion_goal_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_conversion_goal path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignConversionGoals/(?P<campaign_id>.+?)~(?P<category>.+?)~(?P<source>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_criterion_path(
+        customer_id: str, campaign_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_criterion string."""
+        return "customers/{customer_id}/campaignCriteria/{campaign_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_campaign_criterion_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_criterion path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignCriteria/(?P<campaign_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_criterion_simulation_path(
+        customer_id: str,
+        campaign_id: str,
+        criterion_id: str,
+        type: str,
+        modification_method: str,
+        start_date: str,
+        end_date: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_criterion_simulation string."""
+        return "customers/{customer_id}/campaignCriterionSimulations/{campaign_id}~{criterion_id}~{type}~{modification_method}~{start_date}~{end_date}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            criterion_id=criterion_id,
+            type=type,
+            modification_method=modification_method,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    @staticmethod
+    def parse_campaign_criterion_simulation_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_criterion_simulation path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignCriterionSimulations/(?P<campaign_id>.+?)~(?P<criterion_id>.+?)~(?P<type>.+?)~(?P<modification_method>.+?)~(?P<start_date>.+?)~(?P<end_date>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_customizer_path(
+        customer_id: str, campaign_id: str, customizer_attribute_id: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_customizer string."""
+        return "customers/{customer_id}/campaignCustomizers/{campaign_id}~{customizer_attribute_id}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            customizer_attribute_id=customizer_attribute_id,
+        )
+
+    @staticmethod
+    def parse_campaign_customizer_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_customizer path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignCustomizers/(?P<campaign_id>.+?)~(?P<customizer_attribute_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_draft_path(
+        customer_id: str, base_campaign_id: str, draft_id: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_draft string."""
+        return "customers/{customer_id}/campaignDrafts/{base_campaign_id}~{draft_id}".format(
+            customer_id=customer_id,
+            base_campaign_id=base_campaign_id,
+            draft_id=draft_id,
+        )
+
+    @staticmethod
+    def parse_campaign_draft_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_draft path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignDrafts/(?P<base_campaign_id>.+?)~(?P<draft_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_extension_setting_path(
+        customer_id: str, campaign_id: str, extension_type: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_extension_setting string."""
+        return "customers/{customer_id}/campaignExtensionSettings/{campaign_id}~{extension_type}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            extension_type=extension_type,
+        )
+
+    @staticmethod
+    def parse_campaign_extension_setting_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_extension_setting path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignExtensionSettings/(?P<campaign_id>.+?)~(?P<extension_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_feed_path(
+        customer_id: str, campaign_id: str, feed_id: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_feed string."""
+        return "customers/{customer_id}/campaignFeeds/{campaign_id}~{feed_id}".format(
+            customer_id=customer_id, campaign_id=campaign_id, feed_id=feed_id,
+        )
+
+    @staticmethod
+    def parse_campaign_feed_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_feed path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignFeeds/(?P<campaign_id>.+?)~(?P<feed_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_group_path(customer_id: str, campaign_group_id: str,) -> str:
+        """Returns a fully-qualified campaign_group string."""
+        return "customers/{customer_id}/campaignGroups/{campaign_group_id}".format(
+            customer_id=customer_id, campaign_group_id=campaign_group_id,
+        )
+
+    @staticmethod
+    def parse_campaign_group_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_group path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignGroups/(?P<campaign_group_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_label_path(
+        customer_id: str, campaign_id: str, label_id: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_label string."""
+        return "customers/{customer_id}/campaignLabels/{campaign_id}~{label_id}".format(
+            customer_id=customer_id, campaign_id=campaign_id, label_id=label_id,
+        )
+
+    @staticmethod
+    def parse_campaign_label_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_label path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignLabels/(?P<campaign_id>.+?)~(?P<label_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_shared_set_path(
+        customer_id: str, campaign_id: str, shared_set_id: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_shared_set string."""
+        return "customers/{customer_id}/campaignSharedSets/{campaign_id}~{shared_set_id}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            shared_set_id=shared_set_id,
+        )
+
+    @staticmethod
+    def parse_campaign_shared_set_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_shared_set path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignSharedSets/(?P<campaign_id>.+?)~(?P<shared_set_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def campaign_simulation_path(
+        customer_id: str,
+        campaign_id: str,
+        type: str,
+        modification_method: str,
+        start_date: str,
+        end_date: str,
+    ) -> str:
+        """Returns a fully-qualified campaign_simulation string."""
+        return "customers/{customer_id}/campaignSimulations/{campaign_id}~{type}~{modification_method}~{start_date}~{end_date}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            type=type,
+            modification_method=modification_method,
+            start_date=start_date,
+            end_date=end_date,
+        )
+
+    @staticmethod
+    def parse_campaign_simulation_path(path: str) -> Dict[str, str]:
+        """Parses a campaign_simulation path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/campaignSimulations/(?P<campaign_id>.+?)~(?P<type>.+?)~(?P<modification_method>.+?)~(?P<start_date>.+?)~(?P<end_date>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def carrier_constant_path(criterion_id: str,) -> str:
+        """Returns a fully-qualified carrier_constant string."""
+        return "carrierConstants/{criterion_id}".format(
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_carrier_constant_path(path: str) -> Dict[str, str]:
+        """Parses a carrier_constant path into its component segments."""
+        m = re.match(r"^carrierConstants/(?P<criterion_id>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def change_event_path(
+        customer_id: str,
+        timestamp_micros: str,
+        command_index: str,
+        mutate_index: str,
+    ) -> str:
+        """Returns a fully-qualified change_event string."""
+        return "customers/{customer_id}/changeEvents/{timestamp_micros}~{command_index}~{mutate_index}".format(
+            customer_id=customer_id,
+            timestamp_micros=timestamp_micros,
+            command_index=command_index,
+            mutate_index=mutate_index,
+        )
+
+    @staticmethod
+    def parse_change_event_path(path: str) -> Dict[str, str]:
+        """Parses a change_event path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/changeEvents/(?P<timestamp_micros>.+?)~(?P<command_index>.+?)~(?P<mutate_index>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def change_status_path(customer_id: str, change_status_id: str,) -> str:
+        """Returns a fully-qualified change_status string."""
+        return "customers/{customer_id}/changeStatus/{change_status_id}".format(
+            customer_id=customer_id, change_status_id=change_status_id,
+        )
+
+    @staticmethod
+    def parse_change_status_path(path: str) -> Dict[str, str]:
+        """Parses a change_status path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/changeStatus/(?P<change_status_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def click_view_path(customer_id: str, date: str, gclid: str,) -> str:
+        """Returns a fully-qualified click_view string."""
+        return "customers/{customer_id}/clickViews/{date}~{gclid}".format(
+            customer_id=customer_id, date=date, gclid=gclid,
+        )
+
+    @staticmethod
+    def parse_click_view_path(path: str) -> Dict[str, str]:
+        """Parses a click_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/clickViews/(?P<date>.+?)~(?P<gclid>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def combined_audience_path(
+        customer_id: str, combined_audience_id: str,
+    ) -> str:
+        """Returns a fully-qualified combined_audience string."""
+        return "customers/{customer_id}/combinedAudiences/{combined_audience_id}".format(
+            customer_id=customer_id, combined_audience_id=combined_audience_id,
+        )
+
+    @staticmethod
+    def parse_combined_audience_path(path: str) -> Dict[str, str]:
+        """Parses a combined_audience path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/combinedAudiences/(?P<combined_audience_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def conversion_action_path(
+        customer_id: str, conversion_action_id: str,
+    ) -> str:
+        """Returns a fully-qualified conversion_action string."""
+        return "customers/{customer_id}/conversionActions/{conversion_action_id}".format(
+            customer_id=customer_id, conversion_action_id=conversion_action_id,
+        )
+
+    @staticmethod
+    def parse_conversion_action_path(path: str) -> Dict[str, str]:
+        """Parses a conversion_action path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/conversionActions/(?P<conversion_action_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def conversion_custom_variable_path(
+        customer_id: str, conversion_custom_variable_id: str,
+    ) -> str:
+        """Returns a fully-qualified conversion_custom_variable string."""
+        return "customers/{customer_id}/conversionCustomVariables/{conversion_custom_variable_id}".format(
+            customer_id=customer_id,
+            conversion_custom_variable_id=conversion_custom_variable_id,
+        )
+
+    @staticmethod
+    def parse_conversion_custom_variable_path(path: str) -> Dict[str, str]:
+        """Parses a conversion_custom_variable path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/conversionCustomVariables/(?P<conversion_custom_variable_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def conversion_goal_campaign_config_path(
+        customer_id: str, campaign_id: str,
+    ) -> str:
+        """Returns a fully-qualified conversion_goal_campaign_config string."""
+        return "customers/{customer_id}/conversionGoalCampaignConfigs/{campaign_id}".format(
+            customer_id=customer_id, campaign_id=campaign_id,
+        )
+
+    @staticmethod
+    def parse_conversion_goal_campaign_config_path(path: str) -> Dict[str, str]:
+        """Parses a conversion_goal_campaign_config path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/conversionGoalCampaignConfigs/(?P<campaign_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def conversion_value_rule_path(
+        customer_id: str, conversion_value_rule_id: str,
+    ) -> str:
+        """Returns a fully-qualified conversion_value_rule string."""
+        return "customers/{customer_id}/conversionValueRules/{conversion_value_rule_id}".format(
+            customer_id=customer_id,
+            conversion_value_rule_id=conversion_value_rule_id,
+        )
+
+    @staticmethod
+    def parse_conversion_value_rule_path(path: str) -> Dict[str, str]:
+        """Parses a conversion_value_rule path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/conversionValueRules/(?P<conversion_value_rule_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def conversion_value_rule_set_path(
+        customer_id: str, conversion_value_rule_set_id: str,
+    ) -> str:
+        """Returns a fully-qualified conversion_value_rule_set string."""
+        return "customers/{customer_id}/conversionValueRuleSets/{conversion_value_rule_set_id}".format(
+            customer_id=customer_id,
+            conversion_value_rule_set_id=conversion_value_rule_set_id,
+        )
+
+    @staticmethod
+    def parse_conversion_value_rule_set_path(path: str) -> Dict[str, str]:
+        """Parses a conversion_value_rule_set path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/conversionValueRuleSets/(?P<conversion_value_rule_set_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def currency_constant_path(code: str,) -> str:
+        """Returns a fully-qualified currency_constant string."""
+        return "currencyConstants/{code}".format(code=code,)
+
+    @staticmethod
+    def parse_currency_constant_path(path: str) -> Dict[str, str]:
+        """Parses a currency_constant path into its component segments."""
+        m = re.match(r"^currencyConstants/(?P<code>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def custom_audience_path(customer_id: str, custom_audience_id: str,) -> str:
+        """Returns a fully-qualified custom_audience string."""
+        return "customers/{customer_id}/customAudiences/{custom_audience_id}".format(
+            customer_id=customer_id, custom_audience_id=custom_audience_id,
+        )
+
+    @staticmethod
+    def parse_custom_audience_path(path: str) -> Dict[str, str]:
+        """Parses a custom_audience path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customAudiences/(?P<custom_audience_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def custom_conversion_goal_path(customer_id: str, goal_id: str,) -> str:
+        """Returns a fully-qualified custom_conversion_goal string."""
+        return "customers/{customer_id}/customConversionGoals/{goal_id}".format(
+            customer_id=customer_id, goal_id=goal_id,
+        )
+
+    @staticmethod
+    def parse_custom_conversion_goal_path(path: str) -> Dict[str, str]:
+        """Parses a custom_conversion_goal path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customConversionGoals/(?P<goal_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_path(customer_id: str,) -> str:
+        """Returns a fully-qualified customer string."""
+        return "customers/{customer_id}".format(customer_id=customer_id,)
+
+    @staticmethod
+    def parse_customer_path(path: str) -> Dict[str, str]:
+        """Parses a customer path into its component segments."""
+        m = re.match(r"^customers/(?P<customer_id>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_asset_path(
+        customer_id: str, asset_id: str, field_type: str,
+    ) -> str:
+        """Returns a fully-qualified customer_asset string."""
+        return "customers/{customer_id}/customerAssets/{asset_id}~{field_type}".format(
+            customer_id=customer_id, asset_id=asset_id, field_type=field_type,
+        )
+
+    @staticmethod
+    def parse_customer_asset_path(path: str) -> Dict[str, str]:
+        """Parses a customer_asset path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerAssets/(?P<asset_id>.+?)~(?P<field_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_asset_set_path(customer_id: str, asset_set_id: str,) -> str:
+        """Returns a fully-qualified customer_asset_set string."""
+        return "customers/{customer_id}/customerAssetSets/{asset_set_id}".format(
+            customer_id=customer_id, asset_set_id=asset_set_id,
+        )
+
+    @staticmethod
+    def parse_customer_asset_set_path(path: str) -> Dict[str, str]:
+        """Parses a customer_asset_set path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerAssetSets/(?P<asset_set_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_client_path(customer_id: str, client_customer_id: str,) -> str:
+        """Returns a fully-qualified customer_client string."""
+        return "customers/{customer_id}/customerClients/{client_customer_id}".format(
+            customer_id=customer_id, client_customer_id=client_customer_id,
+        )
+
+    @staticmethod
+    def parse_customer_client_path(path: str) -> Dict[str, str]:
+        """Parses a customer_client path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerClients/(?P<client_customer_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_client_link_path(
+        customer_id: str, client_customer_id: str, manager_link_id: str,
+    ) -> str:
+        """Returns a fully-qualified customer_client_link string."""
+        return "customers/{customer_id}/customerClientLinks/{client_customer_id}~{manager_link_id}".format(
+            customer_id=customer_id,
+            client_customer_id=client_customer_id,
+            manager_link_id=manager_link_id,
+        )
+
+    @staticmethod
+    def parse_customer_client_link_path(path: str) -> Dict[str, str]:
+        """Parses a customer_client_link path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerClientLinks/(?P<client_customer_id>.+?)~(?P<manager_link_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_conversion_goal_path(
+        customer_id: str, category: str, source: str,
+    ) -> str:
+        """Returns a fully-qualified customer_conversion_goal string."""
+        return "customers/{customer_id}/customerConversionGoals/{category}~{source}".format(
+            customer_id=customer_id, category=category, source=source,
+        )
+
+    @staticmethod
+    def parse_customer_conversion_goal_path(path: str) -> Dict[str, str]:
+        """Parses a customer_conversion_goal path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerConversionGoals/(?P<category>.+?)~(?P<source>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_customizer_path(
+        customer_id: str, customizer_attribute_id: str,
+    ) -> str:
+        """Returns a fully-qualified customer_customizer string."""
+        return "customers/{customer_id}/customerCustomizers/{customizer_attribute_id}".format(
+            customer_id=customer_id,
+            customizer_attribute_id=customizer_attribute_id,
+        )
+
+    @staticmethod
+    def parse_customer_customizer_path(path: str) -> Dict[str, str]:
+        """Parses a customer_customizer path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerCustomizers/(?P<customizer_attribute_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_extension_setting_path(
+        customer_id: str, extension_type: str,
+    ) -> str:
+        """Returns a fully-qualified customer_extension_setting string."""
+        return "customers/{customer_id}/customerExtensionSettings/{extension_type}".format(
+            customer_id=customer_id, extension_type=extension_type,
+        )
+
+    @staticmethod
+    def parse_customer_extension_setting_path(path: str) -> Dict[str, str]:
+        """Parses a customer_extension_setting path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerExtensionSettings/(?P<extension_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_feed_path(customer_id: str, feed_id: str,) -> str:
+        """Returns a fully-qualified customer_feed string."""
+        return "customers/{customer_id}/customerFeeds/{feed_id}".format(
+            customer_id=customer_id, feed_id=feed_id,
+        )
+
+    @staticmethod
+    def parse_customer_feed_path(path: str) -> Dict[str, str]:
+        """Parses a customer_feed path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerFeeds/(?P<feed_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_label_path(customer_id: str, label_id: str,) -> str:
+        """Returns a fully-qualified customer_label string."""
+        return "customers/{customer_id}/customerLabels/{label_id}".format(
+            customer_id=customer_id, label_id=label_id,
+        )
+
+    @staticmethod
+    def parse_customer_label_path(path: str) -> Dict[str, str]:
+        """Parses a customer_label path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerLabels/(?P<label_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_manager_link_path(
+        customer_id: str, manager_customer_id: str, manager_link_id: str,
+    ) -> str:
+        """Returns a fully-qualified customer_manager_link string."""
+        return "customers/{customer_id}/customerManagerLinks/{manager_customer_id}~{manager_link_id}".format(
+            customer_id=customer_id,
+            manager_customer_id=manager_customer_id,
+            manager_link_id=manager_link_id,
+        )
+
+    @staticmethod
+    def parse_customer_manager_link_path(path: str) -> Dict[str, str]:
+        """Parses a customer_manager_link path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerManagerLinks/(?P<manager_customer_id>.+?)~(?P<manager_link_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_negative_criterion_path(
+        customer_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified customer_negative_criterion string."""
+        return "customers/{customer_id}/customerNegativeCriteria/{criterion_id}".format(
+            customer_id=customer_id, criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_customer_negative_criterion_path(path: str) -> Dict[str, str]:
+        """Parses a customer_negative_criterion path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerNegativeCriteria/(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_user_access_path(customer_id: str, user_id: str,) -> str:
+        """Returns a fully-qualified customer_user_access string."""
+        return "customers/{customer_id}/customerUserAccesses/{user_id}".format(
+            customer_id=customer_id, user_id=user_id,
+        )
+
+    @staticmethod
+    def parse_customer_user_access_path(path: str) -> Dict[str, str]:
+        """Parses a customer_user_access path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerUserAccesses/(?P<user_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customer_user_access_invitation_path(
+        customer_id: str, invitation_id: str,
+    ) -> str:
+        """Returns a fully-qualified customer_user_access_invitation string."""
+        return "customers/{customer_id}/customerUserAccessInvitations/{invitation_id}".format(
+            customer_id=customer_id, invitation_id=invitation_id,
+        )
+
+    @staticmethod
+    def parse_customer_user_access_invitation_path(path: str) -> Dict[str, str]:
+        """Parses a customer_user_access_invitation path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customerUserAccessInvitations/(?P<invitation_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def custom_interest_path(customer_id: str, custom_interest_id: str,) -> str:
+        """Returns a fully-qualified custom_interest string."""
+        return "customers/{customer_id}/customInterests/{custom_interest_id}".format(
+            customer_id=customer_id, custom_interest_id=custom_interest_id,
+        )
+
+    @staticmethod
+    def parse_custom_interest_path(path: str) -> Dict[str, str]:
+        """Parses a custom_interest path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customInterests/(?P<custom_interest_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def customizer_attribute_path(
+        customer_id: str, customizer_attribute_id: str,
+    ) -> str:
+        """Returns a fully-qualified customizer_attribute string."""
+        return "customers/{customer_id}/customizerAttributes/{customizer_attribute_id}".format(
+            customer_id=customer_id,
+            customizer_attribute_id=customizer_attribute_id,
+        )
+
+    @staticmethod
+    def parse_customizer_attribute_path(path: str) -> Dict[str, str]:
+        """Parses a customizer_attribute path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/customizerAttributes/(?P<customizer_attribute_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def detailed_demographic_path(
+        customer_id: str, detailed_demographic_id: str,
+    ) -> str:
+        """Returns a fully-qualified detailed_demographic string."""
+        return "customers/{customer_id}/detailedDemographics/{detailed_demographic_id}".format(
+            customer_id=customer_id,
+            detailed_demographic_id=detailed_demographic_id,
+        )
+
+    @staticmethod
+    def parse_detailed_demographic_path(path: str) -> Dict[str, str]:
+        """Parses a detailed_demographic path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/detailedDemographics/(?P<detailed_demographic_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def detail_placement_view_path(
+        customer_id: str, ad_group_id: str, base64_placement: str,
+    ) -> str:
+        """Returns a fully-qualified detail_placement_view string."""
+        return "customers/{customer_id}/detailPlacementViews/{ad_group_id}~{base64_placement}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            base64_placement=base64_placement,
+        )
+
+    @staticmethod
+    def parse_detail_placement_view_path(path: str) -> Dict[str, str]:
+        """Parses a detail_placement_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/detailPlacementViews/(?P<ad_group_id>.+?)~(?P<base64_placement>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def display_keyword_view_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified display_keyword_view string."""
+        return "customers/{customer_id}/displayKeywordViews/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_display_keyword_view_path(path: str) -> Dict[str, str]:
+        """Parses a display_keyword_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/displayKeywordViews/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def distance_view_path(
+        customer_id: str, placeholder_chain_id: str, distance_bucket: str,
+    ) -> str:
+        """Returns a fully-qualified distance_view string."""
+        return "customers/{customer_id}/distanceViews/{placeholder_chain_id}~{distance_bucket}".format(
+            customer_id=customer_id,
+            placeholder_chain_id=placeholder_chain_id,
+            distance_bucket=distance_bucket,
+        )
+
+    @staticmethod
+    def parse_distance_view_path(path: str) -> Dict[str, str]:
+        """Parses a distance_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/distanceViews/(?P<placeholder_chain_id>.+?)~(?P<distance_bucket>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def domain_category_path(
+        customer_id: str,
+        campaign_id: str,
+        base64_category: str,
+        language_code: str,
+    ) -> str:
+        """Returns a fully-qualified domain_category string."""
+        return "customers/{customer_id}/domainCategories/{campaign_id}~{base64_category}~{language_code}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            base64_category=base64_category,
+            language_code=language_code,
+        )
+
+    @staticmethod
+    def parse_domain_category_path(path: str) -> Dict[str, str]:
+        """Parses a domain_category path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/domainCategories/(?P<campaign_id>.+?)~(?P<base64_category>.+?)~(?P<language_code>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def dynamic_search_ads_search_term_view_path(
+        customer_id: str,
+        ad_group_id: str,
+        search_term_fingerprint: str,
+        headline_fingerprint: str,
+        landing_page_fingerprint: str,
+        page_url_fingerprint: str,
+    ) -> str:
+        """Returns a fully-qualified dynamic_search_ads_search_term_view string."""
+        return "customers/{customer_id}/dynamicSearchAdsSearchTermViews/{ad_group_id}~{search_term_fingerprint}~{headline_fingerprint}~{landing_page_fingerprint}~{page_url_fingerprint}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            search_term_fingerprint=search_term_fingerprint,
+            headline_fingerprint=headline_fingerprint,
+            landing_page_fingerprint=landing_page_fingerprint,
+            page_url_fingerprint=page_url_fingerprint,
+        )
+
+    @staticmethod
+    def parse_dynamic_search_ads_search_term_view_path(
+        path: str,
+    ) -> Dict[str, str]:
+        """Parses a dynamic_search_ads_search_term_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/dynamicSearchAdsSearchTermViews/(?P<ad_group_id>.+?)~(?P<search_term_fingerprint>.+?)~(?P<headline_fingerprint>.+?)~(?P<landing_page_fingerprint>.+?)~(?P<page_url_fingerprint>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def expanded_landing_page_view_path(
+        customer_id: str, expanded_final_url_fingerprint: str,
+    ) -> str:
+        """Returns a fully-qualified expanded_landing_page_view string."""
+        return "customers/{customer_id}/expandedLandingPageViews/{expanded_final_url_fingerprint}".format(
+            customer_id=customer_id,
+            expanded_final_url_fingerprint=expanded_final_url_fingerprint,
+        )
+
+    @staticmethod
+    def parse_expanded_landing_page_view_path(path: str) -> Dict[str, str]:
+        """Parses a expanded_landing_page_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/expandedLandingPageViews/(?P<expanded_final_url_fingerprint>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def experiment_path(customer_id: str, trial_id: str,) -> str:
+        """Returns a fully-qualified experiment string."""
+        return "customers/{customer_id}/experiments/{trial_id}".format(
+            customer_id=customer_id, trial_id=trial_id,
+        )
+
+    @staticmethod
+    def parse_experiment_path(path: str) -> Dict[str, str]:
+        """Parses a experiment path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/experiments/(?P<trial_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def experiment_arm_path(
+        customer_id: str, trial_id: str, trial_arm_id: str,
+    ) -> str:
+        """Returns a fully-qualified experiment_arm string."""
+        return "customers/{customer_id}/experimentArms/{trial_id}~{trial_arm_id}".format(
+            customer_id=customer_id,
+            trial_id=trial_id,
+            trial_arm_id=trial_arm_id,
+        )
+
+    @staticmethod
+    def parse_experiment_arm_path(path: str) -> Dict[str, str]:
+        """Parses a experiment_arm path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/experimentArms/(?P<trial_id>.+?)~(?P<trial_arm_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def extension_feed_item_path(customer_id: str, feed_item_id: str,) -> str:
+        """Returns a fully-qualified extension_feed_item string."""
+        return "customers/{customer_id}/extensionFeedItems/{feed_item_id}".format(
+            customer_id=customer_id, feed_item_id=feed_item_id,
+        )
+
+    @staticmethod
+    def parse_extension_feed_item_path(path: str) -> Dict[str, str]:
+        """Parses a extension_feed_item path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/extensionFeedItems/(?P<feed_item_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def feed_path(customer_id: str, feed_id: str,) -> str:
+        """Returns a fully-qualified feed string."""
+        return "customers/{customer_id}/feeds/{feed_id}".format(
+            customer_id=customer_id, feed_id=feed_id,
+        )
+
+    @staticmethod
+    def parse_feed_path(path: str) -> Dict[str, str]:
+        """Parses a feed path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/feeds/(?P<feed_id>.+?)$", path
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def feed_item_path(
+        customer_id: str, feed_id: str, feed_item_id: str,
+    ) -> str:
+        """Returns a fully-qualified feed_item string."""
+        return "customers/{customer_id}/feedItems/{feed_id}~{feed_item_id}".format(
+            customer_id=customer_id, feed_id=feed_id, feed_item_id=feed_item_id,
+        )
+
+    @staticmethod
+    def parse_feed_item_path(path: str) -> Dict[str, str]:
+        """Parses a feed_item path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/feedItems/(?P<feed_id>.+?)~(?P<feed_item_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def feed_item_set_path(
+        customer_id: str, feed_id: str, feed_item_set_id: str,
+    ) -> str:
+        """Returns a fully-qualified feed_item_set string."""
+        return "customers/{customer_id}/feedItemSets/{feed_id}~{feed_item_set_id}".format(
+            customer_id=customer_id,
+            feed_id=feed_id,
+            feed_item_set_id=feed_item_set_id,
+        )
+
+    @staticmethod
+    def parse_feed_item_set_path(path: str) -> Dict[str, str]:
+        """Parses a feed_item_set path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/feedItemSets/(?P<feed_id>.+?)~(?P<feed_item_set_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def feed_item_set_link_path(
+        customer_id: str,
+        feed_id: str,
+        feed_item_set_id: str,
+        feed_item_id: str,
+    ) -> str:
+        """Returns a fully-qualified feed_item_set_link string."""
+        return "customers/{customer_id}/feedItemSetLinks/{feed_id}~{feed_item_set_id}~{feed_item_id}".format(
+            customer_id=customer_id,
+            feed_id=feed_id,
+            feed_item_set_id=feed_item_set_id,
+            feed_item_id=feed_item_id,
+        )
+
+    @staticmethod
+    def parse_feed_item_set_link_path(path: str) -> Dict[str, str]:
+        """Parses a feed_item_set_link path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/feedItemSetLinks/(?P<feed_id>.+?)~(?P<feed_item_set_id>.+?)~(?P<feed_item_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def feed_item_target_path(
+        customer_id: str,
+        feed_id: str,
+        feed_item_id: str,
+        feed_item_target_type: str,
+        feed_item_target_id: str,
+    ) -> str:
+        """Returns a fully-qualified feed_item_target string."""
+        return "customers/{customer_id}/feedItemTargets/{feed_id}~{feed_item_id}~{feed_item_target_type}~{feed_item_target_id}".format(
+            customer_id=customer_id,
+            feed_id=feed_id,
+            feed_item_id=feed_item_id,
+            feed_item_target_type=feed_item_target_type,
+            feed_item_target_id=feed_item_target_id,
+        )
+
+    @staticmethod
+    def parse_feed_item_target_path(path: str) -> Dict[str, str]:
+        """Parses a feed_item_target path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/feedItemTargets/(?P<feed_id>.+?)~(?P<feed_item_id>.+?)~(?P<feed_item_target_type>.+?)~(?P<feed_item_target_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def feed_mapping_path(
+        customer_id: str, feed_id: str, feed_mapping_id: str,
+    ) -> str:
+        """Returns a fully-qualified feed_mapping string."""
+        return "customers/{customer_id}/feedMappings/{feed_id}~{feed_mapping_id}".format(
+            customer_id=customer_id,
+            feed_id=feed_id,
+            feed_mapping_id=feed_mapping_id,
+        )
+
+    @staticmethod
+    def parse_feed_mapping_path(path: str) -> Dict[str, str]:
+        """Parses a feed_mapping path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/feedMappings/(?P<feed_id>.+?)~(?P<feed_mapping_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def feed_placeholder_view_path(
+        customer_id: str, placeholder_type: str,
+    ) -> str:
+        """Returns a fully-qualified feed_placeholder_view string."""
+        return "customers/{customer_id}/feedPlaceholderViews/{placeholder_type}".format(
+            customer_id=customer_id, placeholder_type=placeholder_type,
+        )
+
+    @staticmethod
+    def parse_feed_placeholder_view_path(path: str) -> Dict[str, str]:
+        """Parses a feed_placeholder_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/feedPlaceholderViews/(?P<placeholder_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def gender_view_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified gender_view string."""
+        return "customers/{customer_id}/genderViews/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_gender_view_path(path: str) -> Dict[str, str]:
+        """Parses a gender_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/genderViews/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def geographic_view_path(
+        customer_id: str, country_criterion_id: str, location_type: str,
+    ) -> str:
+        """Returns a fully-qualified geographic_view string."""
+        return "customers/{customer_id}/geographicViews/{country_criterion_id}~{location_type}".format(
+            customer_id=customer_id,
+            country_criterion_id=country_criterion_id,
+            location_type=location_type,
+        )
+
+    @staticmethod
+    def parse_geographic_view_path(path: str) -> Dict[str, str]:
+        """Parses a geographic_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/geographicViews/(?P<country_criterion_id>.+?)~(?P<location_type>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def geo_target_constant_path(criterion_id: str,) -> str:
+        """Returns a fully-qualified geo_target_constant string."""
+        return "geoTargetConstants/{criterion_id}".format(
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_geo_target_constant_path(path: str) -> Dict[str, str]:
+        """Parses a geo_target_constant path into its component segments."""
+        m = re.match(r"^geoTargetConstants/(?P<criterion_id>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def group_placement_view_path(
+        customer_id: str, ad_group_id: str, base64_placement: str,
+    ) -> str:
+        """Returns a fully-qualified group_placement_view string."""
+        return "customers/{customer_id}/groupPlacementViews/{ad_group_id}~{base64_placement}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            base64_placement=base64_placement,
+        )
+
+    @staticmethod
+    def parse_group_placement_view_path(path: str) -> Dict[str, str]:
+        """Parses a group_placement_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/groupPlacementViews/(?P<ad_group_id>.+?)~(?P<base64_placement>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def hotel_group_view_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified hotel_group_view string."""
+        return "customers/{customer_id}/hotelGroupViews/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_hotel_group_view_path(path: str) -> Dict[str, str]:
+        """Parses a hotel_group_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/hotelGroupViews/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def hotel_performance_view_path(customer_id: str,) -> str:
+        """Returns a fully-qualified hotel_performance_view string."""
+        return "customers/{customer_id}/hotelPerformanceView".format(
+            customer_id=customer_id,
+        )
+
+    @staticmethod
+    def parse_hotel_performance_view_path(path: str) -> Dict[str, str]:
+        """Parses a hotel_performance_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/hotelPerformanceView$", path
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def hotel_reconciliation_path(customer_id: str, commission_id: str,) -> str:
+        """Returns a fully-qualified hotel_reconciliation string."""
+        return "customers/{customer_id}/hotelReconciliations/{commission_id}".format(
+            customer_id=customer_id, commission_id=commission_id,
+        )
+
+    @staticmethod
+    def parse_hotel_reconciliation_path(path: str) -> Dict[str, str]:
+        """Parses a hotel_reconciliation path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/hotelReconciliations/(?P<commission_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def income_range_view_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified income_range_view string."""
+        return "customers/{customer_id}/incomeRangeViews/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_income_range_view_path(path: str) -> Dict[str, str]:
+        """Parses a income_range_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/incomeRangeViews/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def keyword_plan_path(customer_id: str, keyword_plan_id: str,) -> str:
+        """Returns a fully-qualified keyword_plan string."""
+        return "customers/{customer_id}/keywordPlans/{keyword_plan_id}".format(
+            customer_id=customer_id, keyword_plan_id=keyword_plan_id,
+        )
+
+    @staticmethod
+    def parse_keyword_plan_path(path: str) -> Dict[str, str]:
+        """Parses a keyword_plan path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/keywordPlans/(?P<keyword_plan_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def keyword_plan_ad_group_path(
+        customer_id: str, keyword_plan_ad_group_id: str,
+    ) -> str:
+        """Returns a fully-qualified keyword_plan_ad_group string."""
+        return "customers/{customer_id}/keywordPlanAdGroups/{keyword_plan_ad_group_id}".format(
+            customer_id=customer_id,
+            keyword_plan_ad_group_id=keyword_plan_ad_group_id,
+        )
+
+    @staticmethod
+    def parse_keyword_plan_ad_group_path(path: str) -> Dict[str, str]:
+        """Parses a keyword_plan_ad_group path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/keywordPlanAdGroups/(?P<keyword_plan_ad_group_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def keyword_plan_ad_group_keyword_path(
+        customer_id: str, keyword_plan_ad_group_keyword_id: str,
+    ) -> str:
+        """Returns a fully-qualified keyword_plan_ad_group_keyword string."""
+        return "customers/{customer_id}/keywordPlanAdGroupKeywords/{keyword_plan_ad_group_keyword_id}".format(
+            customer_id=customer_id,
+            keyword_plan_ad_group_keyword_id=keyword_plan_ad_group_keyword_id,
+        )
+
+    @staticmethod
+    def parse_keyword_plan_ad_group_keyword_path(path: str) -> Dict[str, str]:
+        """Parses a keyword_plan_ad_group_keyword path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/keywordPlanAdGroupKeywords/(?P<keyword_plan_ad_group_keyword_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def keyword_plan_campaign_path(
+        customer_id: str, keyword_plan_campaign_id: str,
+    ) -> str:
+        """Returns a fully-qualified keyword_plan_campaign string."""
+        return "customers/{customer_id}/keywordPlanCampaigns/{keyword_plan_campaign_id}".format(
+            customer_id=customer_id,
+            keyword_plan_campaign_id=keyword_plan_campaign_id,
+        )
+
+    @staticmethod
+    def parse_keyword_plan_campaign_path(path: str) -> Dict[str, str]:
+        """Parses a keyword_plan_campaign path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/keywordPlanCampaigns/(?P<keyword_plan_campaign_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def keyword_plan_campaign_keyword_path(
+        customer_id: str, keyword_plan_campaign_keyword_id: str,
+    ) -> str:
+        """Returns a fully-qualified keyword_plan_campaign_keyword string."""
+        return "customers/{customer_id}/keywordPlanCampaignKeywords/{keyword_plan_campaign_keyword_id}".format(
+            customer_id=customer_id,
+            keyword_plan_campaign_keyword_id=keyword_plan_campaign_keyword_id,
+        )
+
+    @staticmethod
+    def parse_keyword_plan_campaign_keyword_path(path: str) -> Dict[str, str]:
+        """Parses a keyword_plan_campaign_keyword path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/keywordPlanCampaignKeywords/(?P<keyword_plan_campaign_keyword_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def keyword_theme_constant_path(
+        express_category_id: str, express_sub_category_id: str,
+    ) -> str:
+        """Returns a fully-qualified keyword_theme_constant string."""
+        return "keywordThemeConstants/{express_category_id}~{express_sub_category_id}".format(
+            express_category_id=express_category_id,
+            express_sub_category_id=express_sub_category_id,
+        )
+
+    @staticmethod
+    def parse_keyword_theme_constant_path(path: str) -> Dict[str, str]:
+        """Parses a keyword_theme_constant path into its component segments."""
+        m = re.match(
+            r"^keywordThemeConstants/(?P<express_category_id>.+?)~(?P<express_sub_category_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def keyword_view_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified keyword_view string."""
+        return "customers/{customer_id}/keywordViews/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_keyword_view_path(path: str) -> Dict[str, str]:
+        """Parses a keyword_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/keywordViews/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def label_path(customer_id: str, label_id: str,) -> str:
+        """Returns a fully-qualified label string."""
+        return "customers/{customer_id}/labels/{label_id}".format(
+            customer_id=customer_id, label_id=label_id,
+        )
+
+    @staticmethod
+    def parse_label_path(path: str) -> Dict[str, str]:
+        """Parses a label path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/labels/(?P<label_id>.+?)$", path
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def landing_page_view_path(
+        customer_id: str, unexpanded_final_url_fingerprint: str,
+    ) -> str:
+        """Returns a fully-qualified landing_page_view string."""
+        return "customers/{customer_id}/landingPageViews/{unexpanded_final_url_fingerprint}".format(
+            customer_id=customer_id,
+            unexpanded_final_url_fingerprint=unexpanded_final_url_fingerprint,
+        )
+
+    @staticmethod
+    def parse_landing_page_view_path(path: str) -> Dict[str, str]:
+        """Parses a landing_page_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/landingPageViews/(?P<unexpanded_final_url_fingerprint>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def language_constant_path(criterion_id: str,) -> str:
+        """Returns a fully-qualified language_constant string."""
+        return "languageConstants/{criterion_id}".format(
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_language_constant_path(path: str) -> Dict[str, str]:
+        """Parses a language_constant path into its component segments."""
+        m = re.match(r"^languageConstants/(?P<criterion_id>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def lead_form_submission_data_path(
+        customer_id: str, lead_form_user_submission_id: str,
+    ) -> str:
+        """Returns a fully-qualified lead_form_submission_data string."""
+        return "customers/{customer_id}/leadFormSubmissionData/{lead_form_user_submission_id}".format(
+            customer_id=customer_id,
+            lead_form_user_submission_id=lead_form_user_submission_id,
+        )
+
+    @staticmethod
+    def parse_lead_form_submission_data_path(path: str) -> Dict[str, str]:
+        """Parses a lead_form_submission_data path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/leadFormSubmissionData/(?P<lead_form_user_submission_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def life_event_path(customer_id: str, life_event_id: str,) -> str:
+        """Returns a fully-qualified life_event string."""
+        return "customers/{customer_id}/lifeEvents/{life_event_id}".format(
+            customer_id=customer_id, life_event_id=life_event_id,
+        )
+
+    @staticmethod
+    def parse_life_event_path(path: str) -> Dict[str, str]:
+        """Parses a life_event path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/lifeEvents/(?P<life_event_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def location_view_path(
+        customer_id: str, campaign_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified location_view string."""
+        return "customers/{customer_id}/locationViews/{campaign_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_location_view_path(path: str) -> Dict[str, str]:
+        """Parses a location_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/locationViews/(?P<campaign_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def managed_placement_view_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified managed_placement_view string."""
+        return "customers/{customer_id}/managedPlacementViews/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_managed_placement_view_path(path: str) -> Dict[str, str]:
+        """Parses a managed_placement_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/managedPlacementViews/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def media_file_path(customer_id: str, media_file_id: str,) -> str:
+        """Returns a fully-qualified media_file string."""
+        return "customers/{customer_id}/mediaFiles/{media_file_id}".format(
+            customer_id=customer_id, media_file_id=media_file_id,
+        )
+
+    @staticmethod
+    def parse_media_file_path(path: str) -> Dict[str, str]:
+        """Parses a media_file path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/mediaFiles/(?P<media_file_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def mobile_app_category_constant_path(mobile_app_category_id: str,) -> str:
+        """Returns a fully-qualified mobile_app_category_constant string."""
+        return "mobileAppCategoryConstants/{mobile_app_category_id}".format(
+            mobile_app_category_id=mobile_app_category_id,
+        )
+
+    @staticmethod
+    def parse_mobile_app_category_constant_path(path: str) -> Dict[str, str]:
+        """Parses a mobile_app_category_constant path into its component segments."""
+        m = re.match(
+            r"^mobileAppCategoryConstants/(?P<mobile_app_category_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def mobile_device_constant_path(criterion_id: str,) -> str:
+        """Returns a fully-qualified mobile_device_constant string."""
+        return "mobileDeviceConstants/{criterion_id}".format(
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_mobile_device_constant_path(path: str) -> Dict[str, str]:
+        """Parses a mobile_device_constant path into its component segments."""
+        m = re.match(r"^mobileDeviceConstants/(?P<criterion_id>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def offline_user_data_job_path(
+        customer_id: str, offline_user_data_update_id: str,
+    ) -> str:
+        """Returns a fully-qualified offline_user_data_job string."""
+        return "customers/{customer_id}/offlineUserDataJobs/{offline_user_data_update_id}".format(
+            customer_id=customer_id,
+            offline_user_data_update_id=offline_user_data_update_id,
+        )
+
+    @staticmethod
+    def parse_offline_user_data_job_path(path: str) -> Dict[str, str]:
+        """Parses a offline_user_data_job path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/offlineUserDataJobs/(?P<offline_user_data_update_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def operating_system_version_constant_path(criterion_id: str,) -> str:
+        """Returns a fully-qualified operating_system_version_constant string."""
+        return "operatingSystemVersionConstants/{criterion_id}".format(
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_operating_system_version_constant_path(
+        path: str,
+    ) -> Dict[str, str]:
+        """Parses a operating_system_version_constant path into its component segments."""
+        m = re.match(
+            r"^operatingSystemVersionConstants/(?P<criterion_id>.+?)$", path
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def paid_organic_search_term_view_path(
+        customer_id: str,
+        campaign_id: str,
+        ad_group_id: str,
+        base64_search_term: str,
+    ) -> str:
+        """Returns a fully-qualified paid_organic_search_term_view string."""
+        return "customers/{customer_id}/paidOrganicSearchTermViews/{campaign_id}~{ad_group_id}~{base64_search_term}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            ad_group_id=ad_group_id,
+            base64_search_term=base64_search_term,
+        )
+
+    @staticmethod
+    def parse_paid_organic_search_term_view_path(path: str) -> Dict[str, str]:
+        """Parses a paid_organic_search_term_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/paidOrganicSearchTermViews/(?P<campaign_id>.+?)~(?P<ad_group_id>.+?)~(?P<base64_search_term>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def parental_status_view_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified parental_status_view string."""
+        return "customers/{customer_id}/parentalStatusViews/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_parental_status_view_path(path: str) -> Dict[str, str]:
+        """Parses a parental_status_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/parentalStatusViews/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def payments_account_path(
+        customer_id: str, payments_account_id: str,
+    ) -> str:
+        """Returns a fully-qualified payments_account string."""
+        return "customers/{customer_id}/paymentsAccounts/{payments_account_id}".format(
+            customer_id=customer_id, payments_account_id=payments_account_id,
+        )
+
+    @staticmethod
+    def parse_payments_account_path(path: str) -> Dict[str, str]:
+        """Parses a payments_account path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/paymentsAccounts/(?P<payments_account_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def per_store_view_path(customer_id: str, place_id: str,) -> str:
+        """Returns a fully-qualified per_store_view string."""
+        return "customers/{customer_id}/perStoreViews/{place_id}".format(
+            customer_id=customer_id, place_id=place_id,
+        )
+
+    @staticmethod
+    def parse_per_store_view_path(path: str) -> Dict[str, str]:
+        """Parses a per_store_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/perStoreViews/(?P<place_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def product_bidding_category_constant_path(
+        country_code: str, level: str, id: str,
+    ) -> str:
+        """Returns a fully-qualified product_bidding_category_constant string."""
+        return "productBiddingCategoryConstants/{country_code}~{level}~{id}".format(
+            country_code=country_code, level=level, id=id,
+        )
+
+    @staticmethod
+    def parse_product_bidding_category_constant_path(
+        path: str,
+    ) -> Dict[str, str]:
+        """Parses a product_bidding_category_constant path into its component segments."""
+        m = re.match(
+            r"^productBiddingCategoryConstants/(?P<country_code>.+?)~(?P<level>.+?)~(?P<id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def product_group_view_path(
+        customer_id: str, adgroup_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified product_group_view string."""
+        return "customers/{customer_id}/productGroupViews/{adgroup_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            adgroup_id=adgroup_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_product_group_view_path(path: str) -> Dict[str, str]:
+        """Parses a product_group_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/productGroupViews/(?P<adgroup_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def recommendation_path(customer_id: str, recommendation_id: str,) -> str:
+        """Returns a fully-qualified recommendation string."""
+        return "customers/{customer_id}/recommendations/{recommendation_id}".format(
+            customer_id=customer_id, recommendation_id=recommendation_id,
+        )
+
+    @staticmethod
+    def parse_recommendation_path(path: str) -> Dict[str, str]:
+        """Parses a recommendation path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/recommendations/(?P<recommendation_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def remarketing_action_path(
+        customer_id: str, remarketing_action_id: str,
+    ) -> str:
+        """Returns a fully-qualified remarketing_action string."""
+        return "customers/{customer_id}/remarketingActions/{remarketing_action_id}".format(
+            customer_id=customer_id,
+            remarketing_action_id=remarketing_action_id,
+        )
+
+    @staticmethod
+    def parse_remarketing_action_path(path: str) -> Dict[str, str]:
+        """Parses a remarketing_action path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/remarketingActions/(?P<remarketing_action_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def search_term_view_path(
+        customer_id: str, campaign_id: str, ad_group_id: str, query: str,
+    ) -> str:
+        """Returns a fully-qualified search_term_view string."""
+        return "customers/{customer_id}/searchTermViews/{campaign_id}~{ad_group_id}~{query}".format(
+            customer_id=customer_id,
+            campaign_id=campaign_id,
+            ad_group_id=ad_group_id,
+            query=query,
+        )
+
+    @staticmethod
+    def parse_search_term_view_path(path: str) -> Dict[str, str]:
+        """Parses a search_term_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/searchTermViews/(?P<campaign_id>.+?)~(?P<ad_group_id>.+?)~(?P<query>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def shared_criterion_path(
+        customer_id: str, shared_set_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified shared_criterion string."""
+        return "customers/{customer_id}/sharedCriteria/{shared_set_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            shared_set_id=shared_set_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_shared_criterion_path(path: str) -> Dict[str, str]:
+        """Parses a shared_criterion path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/sharedCriteria/(?P<shared_set_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def shared_set_path(customer_id: str, shared_set_id: str,) -> str:
+        """Returns a fully-qualified shared_set string."""
+        return "customers/{customer_id}/sharedSets/{shared_set_id}".format(
+            customer_id=customer_id, shared_set_id=shared_set_id,
+        )
+
+    @staticmethod
+    def parse_shared_set_path(path: str) -> Dict[str, str]:
+        """Parses a shared_set path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/sharedSets/(?P<shared_set_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def shopping_performance_view_path(customer_id: str,) -> str:
+        """Returns a fully-qualified shopping_performance_view string."""
+        return "customers/{customer_id}/shoppingPerformanceView".format(
+            customer_id=customer_id,
+        )
+
+    @staticmethod
+    def parse_shopping_performance_view_path(path: str) -> Dict[str, str]:
+        """Parses a shopping_performance_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/shoppingPerformanceView$", path
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def smart_campaign_search_term_view_path(
+        customer_id: str, campaign_id: str, query: str,
+    ) -> str:
+        """Returns a fully-qualified smart_campaign_search_term_view string."""
+        return "customers/{customer_id}/smartCampaignSearchTermViews/{campaign_id}~{query}".format(
+            customer_id=customer_id, campaign_id=campaign_id, query=query,
+        )
+
+    @staticmethod
+    def parse_smart_campaign_search_term_view_path(path: str) -> Dict[str, str]:
+        """Parses a smart_campaign_search_term_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/smartCampaignSearchTermViews/(?P<campaign_id>.+?)~(?P<query>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def smart_campaign_setting_path(customer_id: str, campaign_id: str,) -> str:
+        """Returns a fully-qualified smart_campaign_setting string."""
+        return "customers/{customer_id}/smartCampaignSettings/{campaign_id}".format(
+            customer_id=customer_id, campaign_id=campaign_id,
+        )
+
+    @staticmethod
+    def parse_smart_campaign_setting_path(path: str) -> Dict[str, str]:
+        """Parses a smart_campaign_setting path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/smartCampaignSettings/(?P<campaign_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def third_party_app_analytics_link_path(
+        customer_id: str, customer_link_id: str,
+    ) -> str:
+        """Returns a fully-qualified third_party_app_analytics_link string."""
+        return "customers/{customer_id}/thirdPartyAppAnalyticsLinks/{customer_link_id}".format(
+            customer_id=customer_id, customer_link_id=customer_link_id,
+        )
+
+    @staticmethod
+    def parse_third_party_app_analytics_link_path(path: str) -> Dict[str, str]:
+        """Parses a third_party_app_analytics_link path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/thirdPartyAppAnalyticsLinks/(?P<customer_link_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def topic_constant_path(topic_id: str,) -> str:
+        """Returns a fully-qualified topic_constant string."""
+        return "topicConstants/{topic_id}".format(topic_id=topic_id,)
+
+    @staticmethod
+    def parse_topic_constant_path(path: str) -> Dict[str, str]:
+        """Parses a topic_constant path into its component segments."""
+        m = re.match(r"^topicConstants/(?P<topic_id>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def topic_view_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified topic_view string."""
+        return "customers/{customer_id}/topicViews/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_topic_view_path(path: str) -> Dict[str, str]:
+        """Parses a topic_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/topicViews/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def user_interest_path(customer_id: str, user_interest_id: str,) -> str:
+        """Returns a fully-qualified user_interest string."""
+        return "customers/{customer_id}/userInterests/{user_interest_id}".format(
+            customer_id=customer_id, user_interest_id=user_interest_id,
+        )
+
+    @staticmethod
+    def parse_user_interest_path(path: str) -> Dict[str, str]:
+        """Parses a user_interest path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/userInterests/(?P<user_interest_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def user_list_path(customer_id: str, user_list_id: str,) -> str:
+        """Returns a fully-qualified user_list string."""
+        return "customers/{customer_id}/userLists/{user_list_id}".format(
+            customer_id=customer_id, user_list_id=user_list_id,
+        )
+
+    @staticmethod
+    def parse_user_list_path(path: str) -> Dict[str, str]:
+        """Parses a user_list path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/userLists/(?P<user_list_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def user_location_view_path(
+        customer_id: str, country_criterion_id: str, is_targeting_location: str,
+    ) -> str:
+        """Returns a fully-qualified user_location_view string."""
+        return "customers/{customer_id}/userLocationViews/{country_criterion_id}~{is_targeting_location}".format(
+            customer_id=customer_id,
+            country_criterion_id=country_criterion_id,
+            is_targeting_location=is_targeting_location,
+        )
+
+    @staticmethod
+    def parse_user_location_view_path(path: str) -> Dict[str, str]:
+        """Parses a user_location_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/userLocationViews/(?P<country_criterion_id>.+?)~(?P<is_targeting_location>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def video_path(customer_id: str, video_id: str,) -> str:
+        """Returns a fully-qualified video string."""
+        return "customers/{customer_id}/videos/{video_id}".format(
+            customer_id=customer_id, video_id=video_id,
+        )
+
+    @staticmethod
+    def parse_video_path(path: str) -> Dict[str, str]:
+        """Parses a video path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/videos/(?P<video_id>.+?)$", path
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def webpage_view_path(
+        customer_id: str, ad_group_id: str, criterion_id: str,
+    ) -> str:
+        """Returns a fully-qualified webpage_view string."""
+        return "customers/{customer_id}/webpageViews/{ad_group_id}~{criterion_id}".format(
+            customer_id=customer_id,
+            ad_group_id=ad_group_id,
+            criterion_id=criterion_id,
+        )
+
+    @staticmethod
+    def parse_webpage_view_path(path: str) -> Dict[str, str]:
+        """Parses a webpage_view path into its component segments."""
+        m = re.match(
+            r"^customers/(?P<customer_id>.+?)/webpageViews/(?P<ad_group_id>.+?)~(?P<criterion_id>.+?)$",
+            path,
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_billing_account_path(billing_account: str,) -> str:
+        """Returns a fully-qualified billing_account string."""
+        return "billingAccounts/{billing_account}".format(
+            billing_account=billing_account,
+        )
+
+    @staticmethod
+    def parse_common_billing_account_path(path: str) -> Dict[str, str]:
+        """Parse a billing_account path into its component segments."""
+        m = re.match(r"^billingAccounts/(?P<billing_account>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_folder_path(folder: str,) -> str:
+        """Returns a fully-qualified folder string."""
+        return "folders/{folder}".format(folder=folder,)
+
+    @staticmethod
+    def parse_common_folder_path(path: str) -> Dict[str, str]:
+        """Parse a folder path into its component segments."""
+        m = re.match(r"^folders/(?P<folder>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_organization_path(organization: str,) -> str:
+        """Returns a fully-qualified organization string."""
+        return "organizations/{organization}".format(organization=organization,)
+
+    @staticmethod
+    def parse_common_organization_path(path: str) -> Dict[str, str]:
+        """Parse a organization path into its component segments."""
+        m = re.match(r"^organizations/(?P<organization>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_project_path(project: str,) -> str:
+        """Returns a fully-qualified project string."""
+        return "projects/{project}".format(project=project,)
+
+    @staticmethod
+    def parse_common_project_path(path: str) -> Dict[str, str]:
+        """Parse a project path into its component segments."""
+        m = re.match(r"^projects/(?P<project>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_location_path(project: str, location: str,) -> str:
+        """Returns a fully-qualified location string."""
+        return "projects/{project}/locations/{location}".format(
+            project=project, location=location,
+        )
+
+    @staticmethod
+    def parse_common_location_path(path: str) -> Dict[str, str]:
+        """Parse a location path into its component segments."""
+        m = re.match(
+            r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)$", path
+        )
+        return m.groupdict() if m else {}
+
+    def __init__(
+        self,
+        *,
+        credentials: Optional[ga_credentials.Credentials] = None,
+        transport: Union[str, GoogleAdsServiceTransport, None] = None,
+        client_options: Optional[client_options_lib.ClientOptions] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+    ) -> None:
+        """Instantiates the google ads service client.
+
+        Args:
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+            transport (Union[str, GoogleAdsServiceTransport]): The
+                transport to use. If set to None, a transport is chosen
+                automatically.
+            client_options (google.api_core.client_options.ClientOptions): Custom options for the
+                client. It won't take effect if a ``transport`` instance is provided.
+                (1) The ``api_endpoint`` property can be used to override the
+                default endpoint provided by the client. GOOGLE_API_USE_MTLS_ENDPOINT
+                environment variable can also be used to override the endpoint:
+                "always" (always use the default mTLS endpoint), "never" (always
+                use the default regular endpoint) and "auto" (auto switch to the
+                default mTLS endpoint if client certificate is present, this is
+                the default value). However, the ``api_endpoint`` property takes
+                precedence if provided.
+                (2) If GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable
+                is "true", then the ``client_cert_source`` property can be used
+                to provide client certificate for mutual TLS transport. If
+                not provided, the default SSL client certificate will be used if
+                present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not
+                set, no client certificate will be used.
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you're developing
+                your own client library.
+
+        Raises:
+            google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport
+                creation failed for any reason.
+        """
+        if isinstance(client_options, dict):
+            client_options = client_options_lib.from_dict(client_options)
+        if client_options is None:
+            client_options = client_options_lib.ClientOptions()
+
+        # Create SSL credentials for mutual TLS if needed.
+        if os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false") not in (
+            "true",
+            "false",
+        ):
+            raise ValueError(
+                "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`"
+            )
+        use_client_cert = (
+            os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false") == "true"
+        )
+
+        client_cert_source_func = None
+        is_mtls = False
+        if use_client_cert:
+            if client_options.client_cert_source:
+                is_mtls = True
+                client_cert_source_func = client_options.client_cert_source
+            else:
+                is_mtls = mtls.has_default_client_cert_source()
+                if is_mtls:
+                    client_cert_source_func = mtls.default_client_cert_source()
+                else:
+                    client_cert_source_func = None
+
+        # Figure out which api endpoint to use.
+        if client_options.api_endpoint is not None:
+            api_endpoint = client_options.api_endpoint
+        else:
+            use_mtls_env = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto")
+            if use_mtls_env == "never":
+                api_endpoint = self.DEFAULT_ENDPOINT
+            elif use_mtls_env == "always":
+                api_endpoint = self.DEFAULT_MTLS_ENDPOINT
+            elif use_mtls_env == "auto":
+                api_endpoint = (
+                    self.DEFAULT_MTLS_ENDPOINT
+                    if is_mtls
+                    else self.DEFAULT_ENDPOINT
+                )
+            else:
+                raise MutualTLSChannelError(
+                    "Unsupported GOOGLE_API_USE_MTLS_ENDPOINT value. Accepted "
+                    "values: never, auto, always"
+                )
+
+        # Save or instantiate the transport.
+        # Ordinarily, we provide the transport, but allowing a custom transport
+        # instance provides an extensibility point for unusual situations.
+        if isinstance(transport, GoogleAdsServiceTransport):
+            # transport is a GoogleAdsServiceTransport instance.
+            if credentials or client_options.credentials_file:
+                raise ValueError(
+                    "When providing a transport instance, "
+                    "provide its credentials directly."
+                )
+            if client_options.scopes:
+                raise ValueError(
+                    "When providing a transport instance, provide its scopes "
+                    "directly."
+                )
+            self._transport = transport
+        else:
+            Transport = type(self).get_transport_class(transport)
+            self._transport = Transport(
+                credentials=credentials,
+                credentials_file=client_options.credentials_file,
+                host=api_endpoint,
+                scopes=client_options.scopes,
+                client_cert_source_for_mtls=client_cert_source_func,
+                quota_project_id=client_options.quota_project_id,
+                client_info=client_info,
+                always_use_jwt_access=True,
+            )
+
+    def search(
+        self,
+        request: Union[google_ads_service.SearchGoogleAdsRequest, dict] = None,
+        *,
+        customer_id: str = None,
+        query: str = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: float = None,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> pagers.SearchPager:
+        r"""Returns all rows that match the search query.
+
+        List of thrown errors: `AuthenticationError <>`__
+        `AuthorizationError <>`__ `ChangeEventError <>`__
+        `ChangeStatusError <>`__ `ClickViewError <>`__
+        `HeaderError <>`__ `InternalError <>`__ `QueryError <>`__
+        `QuotaError <>`__ `RequestError <>`__
+
+        Args:
+            request (Union[google.ads.googleads.v12.services.types.SearchGoogleAdsRequest, dict]):
+                The request object. Request message for
+                [GoogleAdsService.Search][google.ads.googleads.v12.services.GoogleAdsService.Search].
+            customer_id (str):
+                Required. The ID of the customer
+                being queried.
+
+                This corresponds to the ``customer_id`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            query (str):
+                Required. The query string.
+                This corresponds to the ``query`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+
+        Returns:
+            google.ads.googleads.v12.services.services.google_ads_service.pagers.SearchPager:
+                Response message for
+                [GoogleAdsService.Search][google.ads.googleads.v12.services.GoogleAdsService.Search].
+
+                Iterating over this object will yield results and
+                resolve additional pages automatically.
+
+        """
+        # Create or coerce a protobuf request object.
+        # Quick check: If we got a request object, we should *not* have
+        # gotten any keyword arguments that map to the request.
+        has_flattened_params = any([customer_id, query])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # Minor optimization to avoid making a copy if the user passes
+        # in a google_ads_service.SearchGoogleAdsRequest.
+        # There's no risk of modifying the input as we've already verified
+        # there are no flattened fields.
+        if not isinstance(request, google_ads_service.SearchGoogleAdsRequest):
+            request = google_ads_service.SearchGoogleAdsRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if customer_id is not None:
+                request.customer_id = customer_id
+            if query is not None:
+                request.query = query
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.search]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata(
+                (("customer_id", request.customer_id),)
+            ),
+        )
+
+        # Send the request.
+        response = rpc(
+            request, retry=retry, timeout=timeout, metadata=metadata,
+        )
+
+        # This method is paged; wrap the response in a pager, which provides
+        # an `__iter__` convenience method.
+        response = pagers.SearchPager(
+            method=rpc, request=request, response=response, metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def search_stream(
+        self,
+        request: Union[
+            google_ads_service.SearchGoogleAdsStreamRequest, dict
+        ] = None,
+        *,
+        customer_id: str = None,
+        query: str = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: float = None,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> Iterable[google_ads_service.SearchGoogleAdsStreamResponse]:
+        r"""Returns all rows that match the search stream query.
+
+        List of thrown errors: `AuthenticationError <>`__
+        `AuthorizationError <>`__ `ChangeEventError <>`__
+        `ChangeStatusError <>`__ `ClickViewError <>`__
+        `HeaderError <>`__ `InternalError <>`__ `QueryError <>`__
+        `QuotaError <>`__ `RequestError <>`__
+
+        Args:
+            request (Union[google.ads.googleads.v12.services.types.SearchGoogleAdsStreamRequest, dict]):
+                The request object. Request message for
+                [GoogleAdsService.SearchStream][google.ads.googleads.v12.services.GoogleAdsService.SearchStream].
+            customer_id (str):
+                Required. The ID of the customer
+                being queried.
+
+                This corresponds to the ``customer_id`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            query (str):
+                Required. The query string.
+                This corresponds to the ``query`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+
+        Returns:
+            Iterable[google.ads.googleads.v12.services.types.SearchGoogleAdsStreamResponse]:
+                Response message for
+                [GoogleAdsService.SearchStream][google.ads.googleads.v12.services.GoogleAdsService.SearchStream].
+
+        """
+        # Create or coerce a protobuf request object.
+        # Quick check: If we got a request object, we should *not* have
+        # gotten any keyword arguments that map to the request.
+        has_flattened_params = any([customer_id, query])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # Minor optimization to avoid making a copy if the user passes
+        # in a google_ads_service.SearchGoogleAdsStreamRequest.
+        # There's no risk of modifying the input as we've already verified
+        # there are no flattened fields.
+        if not isinstance(
+            request, google_ads_service.SearchGoogleAdsStreamRequest
+        ):
+            request = google_ads_service.SearchGoogleAdsStreamRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if customer_id is not None:
+                request.customer_id = customer_id
+            if query is not None:
+                request.query = query
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.search_stream]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata(
+                (("customer_id", request.customer_id),)
+            ),
+        )
+
+        # Send the request.
+        response = rpc(
+            request, retry=retry, timeout=timeout, metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def mutate(
+        self,
+        request: Union[google_ads_service.MutateGoogleAdsRequest, dict] = None,
+        *,
+        customer_id: str = None,
+        mutate_operations: Sequence[google_ads_service.MutateOperation] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: float = None,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> google_ads_service.MutateGoogleAdsResponse:
+        r"""Creates, updates, or removes resources. This method supports
+        atomic transactions with multiple types of resources. For
+        example, you can atomically create a campaign and a campaign
+        budget, or perform up to thousands of mutates atomically.
+
+        This method is essentially a wrapper around a series of mutate
+        methods. The only features it offers over calling those methods
+        directly are:
+
+        -  Atomic transactions
+        -  Temp resource names (described below)
+        -  Somewhat reduced latency over making a series of mutate calls
+
+        Note: Only resources that support atomic transactions are
+        included, so this method can't replace all calls to individual
+        services.
+
+        Atomic Transaction Benefits
+        ---------------------------
+
+        Atomicity makes error handling much easier. If you're making a
+        series of changes and one fails, it can leave your account in an
+        inconsistent state. With atomicity, you either reach the chosen
+        state directly, or the request fails and you can retry.
+
+        Temp Resource Names
+        -------------------
+
+        Temp resource names are a special type of resource name used to
+        create a resource and reference that resource in the same
+        request. For example, if a campaign budget is created with
+        ``resource_name`` equal to ``customers/123/campaignBudgets/-1``,
+        that resource name can be reused in the ``Campaign.budget``
+        field in the same request. That way, the two resources are
+        created and linked atomically.
+
+        To create a temp resource name, put a negative number in the
+        part of the name that the server would normally allocate.
+
+        Note:
+
+        -  Resources must be created with a temp name before the name
+           can be reused. For example, the previous
+           CampaignBudget+Campaign example would fail if the mutate
+           order was reversed.
+        -  Temp names are not remembered across requests.
+        -  There's no limit to the number of temp names in a request.
+        -  Each temp name must use a unique negative number, even if the
+           resource types differ.
+
+        Latency
+        -------
+
+        It's important to group mutates by resource type or the request
+        may time out and fail. Latency is roughly equal to a series of
+        calls to individual mutate methods, where each change in
+        resource type is a new call. For example, mutating 10 campaigns
+        then 10 ad groups is like 2 calls, while mutating 1 campaign, 1
+        ad group, 1 campaign, 1 ad group is like 4 calls.
+
+        List of thrown errors: `AdCustomizerError <>`__ `AdError <>`__
+        `AdGroupAdError <>`__ `AdGroupCriterionError <>`__
+        `AdGroupError <>`__ `AssetError <>`__ `AuthenticationError <>`__
+        `AuthorizationError <>`__ `BiddingError <>`__
+        `CampaignBudgetError <>`__ `CampaignCriterionError <>`__
+        `CampaignError <>`__ `CampaignExperimentError <>`__
+        `CampaignSharedSetError <>`__ `CollectionSizeError <>`__
+        `ContextError <>`__ `ConversionActionError <>`__
+        `CriterionError <>`__ `CustomerFeedError <>`__
+        `DatabaseError <>`__ `DateError <>`__ `DateRangeError <>`__
+        `DistinctError <>`__ `ExtensionFeedItemError <>`__
+        `ExtensionSettingError <>`__ `FeedAttributeReferenceError <>`__
+        `FeedError <>`__ `FeedItemError <>`__ `FeedItemSetError <>`__
+        `FieldError <>`__ `FieldMaskError <>`__
+        `FunctionParsingError <>`__ `HeaderError <>`__ `ImageError <>`__
+        `InternalError <>`__ `KeywordPlanAdGroupKeywordError <>`__
+        `KeywordPlanCampaignError <>`__ `KeywordPlanError <>`__
+        `LabelError <>`__ `ListOperationError <>`__
+        `MediaUploadError <>`__ `MutateError <>`__
+        `NewResourceCreationError <>`__ `NullError <>`__
+        `OperationAccessDeniedError <>`__ `PolicyFindingError <>`__
+        `PolicyViolationError <>`__ `QuotaError <>`__ `RangeError <>`__
+        `RequestError <>`__ `ResourceCountLimitExceededError <>`__
+        `SettingError <>`__ `SharedSetError <>`__ `SizeLimitError <>`__
+        `StringFormatError <>`__ `StringLengthError <>`__
+        `UrlFieldError <>`__ `UserListError <>`__
+        `YoutubeVideoRegistrationError <>`__
+
+        Args:
+            request (Union[google.ads.googleads.v12.services.types.MutateGoogleAdsRequest, dict]):
+                The request object. Request message for
+                [GoogleAdsService.Mutate][google.ads.googleads.v12.services.GoogleAdsService.Mutate].
+            customer_id (str):
+                Required. The ID of the customer
+                whose resources are being modified.
+
+                This corresponds to the ``customer_id`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            mutate_operations (Sequence[google.ads.googleads.v12.services.types.MutateOperation]):
+                Required. The list of operations to
+                perform on individual resources.
+
+                This corresponds to the ``mutate_operations`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+
+        Returns:
+            google.ads.googleads.v12.services.types.MutateGoogleAdsResponse:
+                Response message for
+                [GoogleAdsService.Mutate][google.ads.googleads.v12.services.GoogleAdsService.Mutate].
+
+        """
+        # Create or coerce a protobuf request object.
+        # Quick check: If we got a request object, we should *not* have
+        # gotten any keyword arguments that map to the request.
+        has_flattened_params = any([customer_id, mutate_operations])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # Minor optimization to avoid making a copy if the user passes
+        # in a google_ads_service.MutateGoogleAdsRequest.
+        # There's no risk of modifying the input as we've already verified
+        # there are no flattened fields.
+        if not isinstance(request, google_ads_service.MutateGoogleAdsRequest):
+            request = google_ads_service.MutateGoogleAdsRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if customer_id is not None:
+                request.customer_id = customer_id
+            if mutate_operations is not None:
+                request.mutate_operations = mutate_operations
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.mutate]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata(
+                (("customer_id", request.customer_id),)
+            ),
+        )
+
+        # Send the request.
+        response = rpc(
+            request, retry=retry, timeout=timeout, metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+
+try:
+    DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+        gapic_version=pkg_resources.get_distribution("google-ads",).version,
+    )
+except pkg_resources.DistributionNotFound:
+    DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo()
+
+
+__all__ = ("GoogleAdsServiceClient",)