apache-airflow-providers-google 12.0.0rc2__py3-none-any.whl → 13.0.0__py3-none-any.whl

airflow/providers/google/cloud/operators/dataplex.py

@@ -19,7 +19,8 @@
 from __future__ import annotations
 
 import time
-from collections.abc import Sequence
+from collections.abc import MutableSequence, Sequence
+from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
 from airflow.exceptions import AirflowException
@@ -27,26 +28,50 @@ from airflow.providers.google.cloud.triggers.dataplex import (
     DataplexDataProfileJobTrigger,
     DataplexDataQualityJobTrigger,
 )
+from google.protobuf.json_format import MessageToDict
 
 if TYPE_CHECKING:
-    from google.protobuf.field_mask_pb2 import FieldMask
-
     from airflow.utils.context import Context
+    from google.protobuf.field_mask_pb2 import FieldMask
 
-from google.api_core.exceptions import AlreadyExists, GoogleAPICallError
-from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
-from google.api_core.retry import Retry, exponential_sleep_generator
-from google.cloud.dataplex_v1.types import Asset, DataScan, DataScanJob, Lake, Task, Zone
 from googleapiclient.errors import HttpError
 
 from airflow.configuration import conf
 from airflow.providers.google.cloud.hooks.dataplex import AirflowDataQualityScanException, DataplexHook
 from airflow.providers.google.cloud.links.dataplex import (
+    DataplexCatalogAspectTypeLink,
+    DataplexCatalogAspectTypesLink,
+    DataplexCatalogEntryGroupLink,
+    DataplexCatalogEntryGroupsLink,
+    DataplexCatalogEntryLink,
+    DataplexCatalogEntryTypeLink,
+    DataplexCatalogEntryTypesLink,
     DataplexLakeLink,
     DataplexTaskLink,
     DataplexTasksLink,
 )
 from airflow.providers.google.cloud.operators.cloud_base import GoogleCloudBaseOperator
+from google.api_core.exceptions import AlreadyExists, GoogleAPICallError, NotFound
+from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
+from google.api_core.retry import Retry, exponential_sleep_generator
+from google.cloud.dataplex_v1.types import (
+    AspectType,
+    Asset,
+    DataScan,
+    DataScanJob,
+    Entry,
+    EntryGroup,
+    EntryType,
+    EntryView,
+    Lake,
+    ListAspectTypesResponse,
+    ListEntriesResponse,
+    ListEntryGroupsResponse,
+    ListEntryTypesResponse,
+    SearchEntriesResponse,
+    Task,
+    Zone,
+)
 
 
 class DataplexCreateTaskOperator(GoogleCloudBaseOperator):
@@ -2093,3 +2118,2017 @@ class DataplexDeleteAssetOperator(GoogleCloudBaseOperator):
         )
         hook.wait_for_operation(timeout=self.timeout, operation=operation)
         self.log.info("Dataplex asset %s deleted successfully!", self.asset_id)
+
+
+class DataplexCatalogBaseOperator(GoogleCloudBaseOperator):
+    """
+    Base class for all Dataplex Catalog operators.
+
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = (
+        "project_id",
+        "location",
+        "gcp_conn_id",
+        "impersonation_chain",
+    )
+
+    def __init__(
+        self,
+        project_id: str,
+        location: str,
+        gcp_conn_id: str = "google_cloud_default",
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        metadata: Sequence[tuple[str, str]] = (),
+        impersonation_chain: str | Sequence[str] | None = None,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self.project_id = project_id
+        self.location = location
+        self.gcp_conn_id = gcp_conn_id
+        self.impersonation_chain = impersonation_chain
+        self.retry = retry
+        self.timeout = timeout
+        self.metadata = metadata
+
+    @cached_property
+    def hook(self) -> DataplexHook:
+        return DataplexHook(
+            gcp_conn_id=self.gcp_conn_id,
+            impersonation_chain=self.impersonation_chain,
+        )
+
+
+class DataplexCatalogCreateEntryGroupOperator(DataplexCatalogBaseOperator):
+    """
+    Create an EntryGroup resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogCreateEntryGroupOperator`
+
+    :param entry_group_id: Required. EntryGroup identifier.
+    :param entry_group_configuration: Required. EntryGroup configuration.
+        For more details please see API documentation:
+        https://cloud.google.com/dataplex/docs/reference/rest/v1/projects.locations.entryGroups#EntryGroup
+    :param validate_request: Optional. If set, performs request validation, but does not actually
+        execute the request.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_group_id", "entry_group_configuration"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogEntryGroupLink(),)
+
+    def __init__(
+        self,
+        entry_group_id: str,
+        entry_group_configuration: EntryGroup | dict,
+        validate_request: bool = False,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_group_id = entry_group_id
+        self.entry_group_configuration = entry_group_configuration
+        self.validate_request = validate_request
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryGroupLink.persist(
+            context=context,
+            task_instance=self,
+        )
+
+        if self.validate_request:
+            self.log.info("Validating a Create Dataplex Catalog EntryGroup request.")
+        else:
+            self.log.info("Creating a Dataplex Catalog EntryGroup.")
+
+        try:
+            operation = self.hook.create_entry_group(
+                entry_group_id=self.entry_group_id,
+                entry_group_configuration=self.entry_group_configuration,
+                location=self.location,
+                project_id=self.project_id,
+                validate_only=self.validate_request,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            entry_group = self.hook.wait_for_operation(timeout=self.timeout, operation=operation)
+        except AlreadyExists:
+            entry_group = self.hook.get_entry_group(
+                entry_group_id=self.entry_group_id,
+                location=self.location,
+                project_id=self.project_id,
+            )
+            self.log.info(
+                "Dataplex Catalog EntryGroup %s already exists.",
+                self.entry_group_id,
+            )
+            result = EntryGroup.to_dict(entry_group)
+            return result
+        except Exception as ex:
+            raise AirflowException(ex)
+        else:
+            result = EntryGroup.to_dict(entry_group) if not self.validate_request else None
+
+        if not self.validate_request:
+            self.log.info("Dataplex Catalog EntryGroup %s was successfully created.", self.entry_group_id)
+        return result
+
+
+class DataplexCatalogGetEntryGroupOperator(DataplexCatalogBaseOperator):
+    """
+    Get an EntryGroup resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogGetEntryGroupOperator`
+
+    :param entry_group_id: Required. EntryGroup identifier.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_group_id"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogEntryGroupLink(),)
+
+    def __init__(
+        self,
+        entry_group_id: str,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_group_id = entry_group_id
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryGroupLink.persist(
+            context=context,
+            task_instance=self,
+        )
+        self.log.info(
+            "Retrieving Dataplex Catalog EntryGroup %s.",
+            self.entry_group_id,
+        )
+        try:
+            entry_group = self.hook.get_entry_group(
+                entry_group_id=self.entry_group_id,
+                location=self.location,
+                project_id=self.project_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+        except NotFound:
+            self.log.info(
+                "Dataplex Catalog EntryGroup %s not found.",
+                self.entry_group_id,
+            )
+            raise AirflowException(NotFound)
+        except Exception as ex:
+            raise AirflowException(ex)
+
+        return EntryGroup.to_dict(entry_group)
+
+
+class DataplexCatalogDeleteEntryGroupOperator(DataplexCatalogBaseOperator):
+    """
+    Delete an EntryGroup resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogDeleteEntryGroupOperator`
+
+    :param entry_group_id: Required. EntryGroup identifier.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_group_id"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+
+    def __init__(
+        self,
+        entry_group_id: str,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_group_id = entry_group_id
+
+    def execute(self, context: Context):
+        self.log.info(
+            "Deleting Dataplex Catalog EntryGroup %s.",
+            self.entry_group_id,
+        )
+        try:
+            operation = self.hook.delete_entry_group(
+                entry_group_id=self.entry_group_id,
+                location=self.location,
+                project_id=self.project_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            self.hook.wait_for_operation(timeout=self.timeout, operation=operation)
+
+        except NotFound:
+            self.log.info(
+                "Dataplex Catalog EntryGroup %s not found.",
+                self.entry_group_id,
+            )
+            raise AirflowException(NotFound)
+        except Exception as ex:
+            raise AirflowException(ex)
+        return None
+
+
+class DataplexCatalogListEntryGroupsOperator(DataplexCatalogBaseOperator):
+    """
+    List EntryGroup resources.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogListEntryGroupsOperator`
+
+    :param filter_by: Optional. Filter to apply on the list results.
+    :param order_by: Optional. Fields to order the results by.
+    :param page_size: Optional. Maximum number of EntryGroups to return on the page.
+    :param page_token: Optional. Token to retrieve the next page of results.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(DataplexCatalogBaseOperator.template_fields)
+    operator_extra_links = (DataplexCatalogEntryGroupsLink(),)
+
+    def __init__(
+        self,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        filter_by: str | None = None,
+        order_by: str | None = None,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.page_size = page_size
+        self.page_token = page_token
+        self.filter_by = filter_by
+        self.order_by = order_by
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryGroupsLink.persist(
+            context=context,
+            task_instance=self,
+        )
+        self.log.info(
+            "Listing Dataplex Catalog EntryGroup from location %s.",
+            self.location,
+        )
+        try:
+            entry_group_on_page = self.hook.list_entry_groups(
+                location=self.location,
+                project_id=self.project_id,
+                page_size=self.page_size,
+                page_token=self.page_token,
+                filter_by=self.filter_by,
+                order_by=self.order_by,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            self.log.info("EntryGroup on page: %s", entry_group_on_page)
+            self.xcom_push(
+                context=context,
+                key="entry_group_page",
+                value=ListEntryGroupsResponse.to_dict(entry_group_on_page._response),
+            )
+        except Exception as ex:
+            raise AirflowException(ex)
+
+        # Constructing list to return EntryGroups in readable format
+        entry_groups_list = [
+            MessageToDict(entry_group._pb, preserving_proto_field_name=True)
+            for entry_group in next(iter(entry_group_on_page.pages)).entry_groups
+        ]
+        return entry_groups_list
+
+
+class DataplexCatalogUpdateEntryGroupOperator(DataplexCatalogBaseOperator):
+    """
+    Update an EntryGroup resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogUpdateEntryGroupOperator`
+
+    :param project_id: Required. The ID of the Google Cloud project that the task belongs to.
+    :param location: Required. The ID of the Google Cloud region that the task belongs to.
+    :param update_mask: Optional. Names of fields whose values to overwrite on an entry group.
+        If this parameter is absent or empty, all modifiable fields are overwritten. If such
+        fields are non-required and omitted in the request body, their values are emptied.
+    :param entry_group_id: Required. ID of the EntryGroup to update.
+    :param entry_group_configuration: Required. The updated configuration body of the EntryGroup.
+        For more details please see API documentation:
+        https://cloud.google.com/dataplex/docs/reference/rest/v1/projects.locations.entryGroups#EntryGroup
+    :param validate_only: Optional. The service validates the request without performing any mutations.
+    :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+        will not be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param gcp_conn_id: Optional. The connection ID to use when fetching connection info.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_group_id", "entry_group_configuration", "update_mask"}
+        | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogEntryGroupLink(),)
+
+    def __init__(
+        self,
+        entry_group_id: str,
+        entry_group_configuration: dict | EntryGroup,
+        update_mask: list[str] | FieldMask | None = None,
+        validate_request: bool | None = False,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_group_id = entry_group_id
+        self.entry_group_configuration = entry_group_configuration
+        self.update_mask = update_mask
+        self.validate_request = validate_request
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryGroupLink.persist(
+            context=context,
+            task_instance=self,
+        )
+
+        if self.validate_request:
+            self.log.info("Validating an Update Dataplex Catalog EntryGroup request.")
+        else:
+            self.log.info(
+                "Updating Dataplex Catalog EntryGroup %s.",
+                self.entry_group_id,
+            )
+        try:
+            operation = self.hook.update_entry_group(
+                location=self.location,
+                project_id=self.project_id,
+                entry_group_id=self.entry_group_id,
+                entry_group_configuration=self.entry_group_configuration,
+                update_mask=self.update_mask,
+                validate_only=self.validate_request,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            entry_group = self.hook.wait_for_operation(timeout=self.timeout, operation=operation)
+
+        except NotFound as ex:
+            self.log.info("Specified EntryGroup was not found.")
+            raise AirflowException(ex)
+        except Exception as exc:
+            raise AirflowException(exc)
+        else:
+            result = EntryGroup.to_dict(entry_group) if not self.validate_request else None
+
+        if not self.validate_request:
+            self.log.info("EntryGroup %s was successfully updated.", self.entry_group_id)
+        return result
+
+
+class DataplexCatalogCreateEntryTypeOperator(DataplexCatalogBaseOperator):
+    """
+    Create an EntryType resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogCreateEntryTypeOperator`
+
+    :param entry_type_id: Required. EntryType identifier.
+    :param entry_type_configuration: Required. EntryType configuration.
+        For more details please see API documentation:
+        https://cloud.google.com/dataplex/docs/reference/rest/v1/projects.locations.entryGroups#EntryGroup
+    :param validate_request: Optional. If set, performs request validation, but does not actually
+        execute the request.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_type_id", "entry_type_configuration"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogEntryTypeLink(),)
+
+    def __init__(
+        self,
+        entry_type_id: str,
+        entry_type_configuration: EntryType | dict,
+        validate_request: bool = False,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_type_id = entry_type_id
+        self.entry_type_configuration = entry_type_configuration
+        self.validate_request = validate_request
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryTypeLink.persist(
+            context=context,
+            task_instance=self,
+        )
+
+        if self.validate_request:
+            self.log.info("Validating a Create Dataplex Catalog EntryType request.")
+        else:
+            self.log.info("Creating a Dataplex Catalog EntryType.")
+
+        try:
+            operation = self.hook.create_entry_type(
+                entry_type_id=self.entry_type_id,
+                entry_type_configuration=self.entry_type_configuration,
+                location=self.location,
+                project_id=self.project_id,
+                validate_only=self.validate_request,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            entry_type = self.hook.wait_for_operation(timeout=self.timeout, operation=operation)
+        except AlreadyExists:
+            entry_type = self.hook.get_entry_type(
+                entry_type_id=self.entry_type_id,
+                location=self.location,
+                project_id=self.project_id,
+            )
+            self.log.info(
+                "Dataplex Catalog EntryType %s already exists.",
+                self.entry_type_id,
+            )
+            result = EntryType.to_dict(entry_type)
+            return result
+        except Exception as ex:
+            raise AirflowException(ex)
+        else:
+            result = EntryType.to_dict(entry_type) if not self.validate_request else None
+
+        if not self.validate_request:
+            self.log.info("Dataplex Catalog EntryType %s was successfully created.", self.entry_type_id)
+        return result
+
+
+class DataplexCatalogGetEntryTypeOperator(DataplexCatalogBaseOperator):
+    """
+    Get an EntryType resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogGetEntryTypeOperator`
+
+    :param entry_type_id: Required. EntryType identifier.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_type_id"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogEntryTypeLink(),)
+
+    def __init__(
+        self,
+        entry_type_id: str,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_type_id = entry_type_id
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryTypeLink.persist(
+            context=context,
+            task_instance=self,
+        )
+        self.log.info(
+            "Retrieving Dataplex Catalog EntryType %s.",
+            self.entry_type_id,
+        )
+        try:
+            entry_type = self.hook.get_entry_type(
+                entry_type_id=self.entry_type_id,
+                location=self.location,
+                project_id=self.project_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+        except NotFound:
+            self.log.info(
+                "Dataplex Catalog EntryType %s not found.",
+                self.entry_type_id,
+            )
+            raise AirflowException(NotFound)
+        except Exception as ex:
+            raise AirflowException(ex)
+
+        return EntryType.to_dict(entry_type)
+
+
+class DataplexCatalogDeleteEntryTypeOperator(DataplexCatalogBaseOperator):
+    """
+    Delete an EntryType resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogDeleteEntryTypeOperator`
+
+    :param entry_type_id: Required. EntryType identifier.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_type_id"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+
+    def __init__(
+        self,
+        entry_type_id: str,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_type_id = entry_type_id
+
+    def execute(self, context: Context):
+        self.log.info(
+            "Deleting Dataplex Catalog EntryType %s.",
+            self.entry_type_id,
+        )
+        try:
+            operation = self.hook.delete_entry_type(
+                entry_type_id=self.entry_type_id,
+                location=self.location,
+                project_id=self.project_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            self.hook.wait_for_operation(timeout=self.timeout, operation=operation)
+
+        except NotFound:
+            self.log.info(
+                "Dataplex Catalog EntryType %s not found.",
+                self.entry_type_id,
+            )
+            raise AirflowException(NotFound)
+        except Exception as ex:
+            raise AirflowException(ex)
+        return None
+
+
+class DataplexCatalogListEntryTypesOperator(DataplexCatalogBaseOperator):
+    """
+    List EntryType resources.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogListEntryTypesOperator`
+
+    :param filter_by: Optional. Filter to apply on the list results.
+    :param order_by: Optional. Fields to order the results by.
+    :param page_size: Optional. Maximum number of EntryTypes to return on the page.
+    :param page_token: Optional. Token to retrieve the next page of results.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(DataplexCatalogBaseOperator.template_fields)
+    operator_extra_links = (DataplexCatalogEntryTypesLink(),)
+
+    def __init__(
+        self,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        filter_by: str | None = None,
+        order_by: str | None = None,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.page_size = page_size
+        self.page_token = page_token
+        self.filter_by = filter_by
+        self.order_by = order_by
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryTypesLink.persist(
+            context=context,
+            task_instance=self,
+        )
+        self.log.info(
+            "Listing Dataplex Catalog EntryType from location %s.",
+            self.location,
+        )
+        try:
+            entry_type_on_page = self.hook.list_entry_types(
+                location=self.location,
+                project_id=self.project_id,
+                page_size=self.page_size,
+                page_token=self.page_token,
+                filter_by=self.filter_by,
+                order_by=self.order_by,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            self.log.info("EntryType on page: %s", entry_type_on_page)
+            self.xcom_push(
+                context=context,
+                key="entry_type_page",
+                value=ListEntryTypesResponse.to_dict(entry_type_on_page._response),
+            )
+        except Exception as ex:
+            raise AirflowException(ex)
+
+        # Constructing list to return EntryTypes in readable format
+        entry_types_list = [
+            MessageToDict(entry_type._pb, preserving_proto_field_name=True)
+            for entry_type in next(iter(entry_type_on_page.pages)).entry_types
+        ]
+        return entry_types_list
+
+
+class DataplexCatalogUpdateEntryTypeOperator(DataplexCatalogBaseOperator):
+    """
+    Update an EntryType resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogUpdateEntryTypeOperator`
+
+    :param project_id: Required. The ID of the Google Cloud project that the task belongs to.
+    :param location: Required. The ID of the Google Cloud region that the task belongs to.
+    :param update_mask: Optional. Names of fields whose values to overwrite on an entry group.
+        If this parameter is absent or empty, all modifiable fields are overwritten. If such
+        fields are non-required and omitted in the request body, their values are emptied.
+    :param entry_type_id: Required. ID of the EntryType to update.
+    :param entry_type_configuration: Required. The updated configuration body of the EntryType.
+        For more details please see API documentation:
+        https://cloud.google.com/dataplex/docs/reference/rest/v1/projects.locations.entryGroups#EntryGroup
+    :param validate_only: Optional. The service validates the request without performing any mutations.
+    :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+        will not be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param gcp_conn_id: Optional. The connection ID to use when fetching connection info.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_type_id", "entry_type_configuration", "update_mask"}
+        | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogEntryTypeLink(),)
+
+    def __init__(
+        self,
+        entry_type_id: str,
+        entry_type_configuration: dict | EntryType,
+        update_mask: list[str] | FieldMask | None = None,
+        validate_request: bool | None = False,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_type_id = entry_type_id
+        self.entry_type_configuration = entry_type_configuration
+        self.update_mask = update_mask
+        self.validate_request = validate_request
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryTypeLink.persist(
+            context=context,
+            task_instance=self,
+        )
+
+        if self.validate_request:
+            self.log.info("Validating an Update Dataplex Catalog EntryType request.")
+        else:
+            self.log.info(
+                "Updating Dataplex Catalog EntryType %s.",
+                self.entry_type_id,
+            )
+        try:
+            operation = self.hook.update_entry_type(
+                location=self.location,
+                project_id=self.project_id,
+                entry_type_id=self.entry_type_id,
+                entry_type_configuration=self.entry_type_configuration,
+                update_mask=self.update_mask,
+                validate_only=self.validate_request,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            entry_type = self.hook.wait_for_operation(timeout=self.timeout, operation=operation)
+
+        except NotFound as ex:
+            self.log.info("Specified EntryType was not found.")
+            raise AirflowException(ex)
+        except Exception as exc:
+            raise AirflowException(exc)
+        else:
+            result = EntryType.to_dict(entry_type) if not self.validate_request else None
+
+        if not self.validate_request:
+            self.log.info("EntryType %s was successfully updated.", self.entry_type_id)
+        return result
+
+
+class DataplexCatalogCreateAspectTypeOperator(DataplexCatalogBaseOperator):
+    """
+    Create an AspectType resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogCreateAspectTypeOperator`
+
+    :param aspect_type_id: Required. AspectType identifier.
+    :param aspect_type_configuration: Required. AspectType configuration.
+        For more details please see API documentation:
+        https://cloud.google.com/dataplex/docs/reference/rest/v1/projects.locations.aspectTypes#AspectType
+    :param validate_request: Optional. If set, performs request validation, but does not actually
+        execute the request.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"aspect_type_id", "aspect_type_configuration"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogAspectTypeLink(),)
+
+    def __init__(
+        self,
+        aspect_type_id: str,
+        aspect_type_configuration: AspectType | dict,
+        validate_request: bool = False,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.aspect_type_id = aspect_type_id
+        self.aspect_type_configuration = aspect_type_configuration
+        self.validate_request = validate_request
+
+    def execute(self, context: Context):
+        DataplexCatalogAspectTypeLink.persist(
+            context=context,
+            task_instance=self,
+        )
+
+        if self.validate_request:
+            self.log.info("Validating a Create Dataplex Catalog AspectType request.")
+        else:
+            self.log.info("Creating a Dataplex Catalog AspectType.")
+
+        try:
+            operation = self.hook.create_aspect_type(
+                aspect_type_id=self.aspect_type_id,
+                aspect_type_configuration=self.aspect_type_configuration,
+                location=self.location,
+                project_id=self.project_id,
+                validate_only=self.validate_request,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            aspect_type = self.hook.wait_for_operation(timeout=self.timeout, operation=operation)
+        except AlreadyExists:
+            aspect_type = self.hook.get_aspect_type(
+                aspect_type_id=self.aspect_type_id,
+                location=self.location,
+                project_id=self.project_id,
+            )
+            self.log.info(
+                "Dataplex Catalog AspectType %s already exists.",
+                self.aspect_type_id,
+            )
+            result = AspectType.to_dict(aspect_type)
+            return result
+        except Exception as ex:
+            raise AirflowException(ex)
+        else:
+            result = AspectType.to_dict(aspect_type) if not self.validate_request else None
+
+        if not self.validate_request:
+            self.log.info("Dataplex Catalog AspectType %s was successfully created.", self.aspect_type_id)
+        return result
+
+
+class DataplexCatalogGetAspectTypeOperator(DataplexCatalogBaseOperator):
+    """
+    Get an AspectType resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogGetAspectTypeOperator`
+
+    :param aspect_type_id: Required. AspectType identifier.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"aspect_type_id"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogAspectTypeLink(),)
+
+    def __init__(
+        self,
+        aspect_type_id: str,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.aspect_type_id = aspect_type_id
+
+    def execute(self, context: Context):
+        DataplexCatalogAspectTypeLink.persist(
+            context=context,
+            task_instance=self,
+        )
+        self.log.info(
+            "Retrieving Dataplex Catalog AspectType %s.",
+            self.aspect_type_id,
+        )
+        try:
+            aspect_type = self.hook.get_aspect_type(
+                aspect_type_id=self.aspect_type_id,
+                location=self.location,
+                project_id=self.project_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+        except NotFound:
+            self.log.info(
+                "Dataplex Catalog AspectType %s not found.",
+                self.aspect_type_id,
+            )
+            raise AirflowException(NotFound)
+        except Exception as ex:
+            raise AirflowException(ex)
+
+        return AspectType.to_dict(aspect_type)
+
+
+class DataplexCatalogListAspectTypesOperator(DataplexCatalogBaseOperator):
+    """
+    List AspectType resources.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogListAspectTypesOperator`
+
+    :param filter_by: Optional. Filter to apply on the list results.
+    :param order_by: Optional. Fields to order the results by.
+    :param page_size: Optional. Maximum number of AspectTypes to return on the page.
+    :param page_token: Optional. Token to retrieve the next page of results.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(DataplexCatalogBaseOperator.template_fields)
+    operator_extra_links = (DataplexCatalogAspectTypesLink(),)
+
+    def __init__(
+        self,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        filter_by: str | None = None,
+        order_by: str | None = None,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.page_size = page_size
+        self.page_token = page_token
+        self.filter_by = filter_by
+        self.order_by = order_by
+
+    def execute(self, context: Context):
+        DataplexCatalogAspectTypesLink.persist(
+            context=context,
+            task_instance=self,
+        )
+        self.log.info(
+            "Listing Dataplex Catalog AspectType from location %s.",
+            self.location,
+        )
+        try:
+            aspect_type_on_page = self.hook.list_aspect_types(
+                location=self.location,
+                project_id=self.project_id,
+                page_size=self.page_size,
+                page_token=self.page_token,
+                filter_by=self.filter_by,
+                order_by=self.order_by,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            self.log.info("AspectType on page: %s", aspect_type_on_page)
+            self.xcom_push(
+                context=context,
+                key="aspect_type_page",
+                value=ListAspectTypesResponse.to_dict(aspect_type_on_page._response),
+            )
+        except Exception as ex:
+            raise AirflowException(ex)
+
+        # Constructing list to return AspectTypes in readable format
+        aspect_types_list = [
+            MessageToDict(aspect_type._pb, preserving_proto_field_name=True)
+            for aspect_type in next(iter(aspect_type_on_page.pages)).aspect_types
+        ]
+        return aspect_types_list
+
+
+class DataplexCatalogUpdateAspectTypeOperator(DataplexCatalogBaseOperator):
+    """
+    Update an AspectType resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogUpdateAspectTypeOperator`
+
+    :param project_id: Required. The ID of the Google Cloud project that the task belongs to.
+    :param location: Required. The ID of the Google Cloud region that the task belongs to.
+    :param update_mask: Optional. Names of fields whose values to overwrite on an entry group.
+        If this parameter is absent or empty, all modifiable fields are overwritten. If such
+        fields are non-required and omitted in the request body, their values are emptied.
+    :param aspect_type_id: Required. ID of the AspectType to update.
+    :param aspect_type_configuration: Required. The updated configuration body of the AspectType.
+        For more details please see API documentation:
+        https://cloud.google.com/dataplex/docs/reference/rest/v1/projects.locations.aspectTypes#AspectType
+    :param validate_only: Optional. The service validates the request without performing any mutations.
+    :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+        will not be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param gcp_conn_id: Optional. The connection ID to use when fetching connection info.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"aspect_type_id", "aspect_type_configuration", "update_mask"}
+        | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogAspectTypeLink(),)
+
+    def __init__(
+        self,
+        aspect_type_id: str,
+        aspect_type_configuration: dict | AspectType,
+        update_mask: list[str] | FieldMask | None = None,
+        validate_request: bool | None = False,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.aspect_type_id = aspect_type_id
+        self.aspect_type_configuration = aspect_type_configuration
+        self.update_mask = update_mask
+        self.validate_request = validate_request
+
+    def execute(self, context: Context):
+        DataplexCatalogAspectTypeLink.persist(
+            context=context,
+            task_instance=self,
+        )
+
+        if self.validate_request:
+            self.log.info("Validating an Update Dataplex Catalog AspectType request.")
+        else:
+            self.log.info(
+                "Updating Dataplex Catalog AspectType %s.",
+                self.aspect_type_id,
+            )
+        try:
+            operation = self.hook.update_aspect_type(
+                location=self.location,
+                project_id=self.project_id,
+                aspect_type_id=self.aspect_type_id,
+                aspect_type_configuration=self.aspect_type_configuration,
+                update_mask=self.update_mask,
+                validate_only=self.validate_request,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            aspect_type = self.hook.wait_for_operation(timeout=self.timeout, operation=operation)
+
+        except NotFound as ex:
+            self.log.info("Specified AspectType was not found.")
+            raise AirflowException(ex)
+        except Exception as exc:
+            raise AirflowException(exc)
+        else:
+            result = AspectType.to_dict(aspect_type) if not self.validate_request else None
+
+        if not self.validate_request:
+            self.log.info("AspectType %s was successfully updated.", self.aspect_type_id)
+        return result
+
+
+class DataplexCatalogDeleteAspectTypeOperator(DataplexCatalogBaseOperator):
+    """
+    Delete an AspectType resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogDeleteAspectTypeOperator`
+
+    :param aspect_type_id: Required. AspectType identifier.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"aspect_type_id"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+
+    def __init__(
+        self,
+        aspect_type_id: str,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.aspect_type_id = aspect_type_id
+
+    def execute(self, context: Context):
+        self.log.info(
+            "Deleting Dataplex Catalog AspectType %s.",
+            self.aspect_type_id,
+        )
+        try:
+            operation = self.hook.delete_aspect_type(
+                aspect_type_id=self.aspect_type_id,
+                location=self.location,
+                project_id=self.project_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            self.hook.wait_for_operation(timeout=self.timeout, operation=operation)
+
+        except NotFound:
+            self.log.info(
+                "Dataplex Catalog AspectType %s not found.",
+                self.aspect_type_id,
+            )
+            raise AirflowException(NotFound)
+        except Exception as ex:
+            raise AirflowException(ex)
+        return None
+
+
+class DataplexCatalogCreateEntryOperator(DataplexCatalogBaseOperator):
+    """
+    Create an Entry resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogCreateEntryOperator`
+
+    :param entry_id: Required. Entry identifier. It has to be unique within an Entry Group.
+        Entries corresponding to Google Cloud resources use an Entry ID format based on `full resource
+        names <https://cloud.google.com/apis/design/resource_names#full_resource_name>`__.
+        The format is a full resource name of the resource without the prefix double slashes in the API
+        service name part of the full resource name. This allows retrieval of entries using their associated
+        resource name.
+        For example, if the full resource name of a resource is
+        ``//library.googleapis.com/shelves/shelf1/books/book2``, then the suggested entry_id is
+        ``library.googleapis.com/shelves/shelf1/books/book2``.
+        It is also suggested to follow the same convention for entries corresponding to resources from
+        providers or systems other than Google Cloud.
+        The maximum size of the field is 4000 characters.
+    :param entry_group_id: Required. EntryGroup resource name to which created Entry will belong to.
+    :param entry_configuration: Required. Entry configuration.
+        For more details please see API documentation:
+        https://cloud.google.com/dataplex/docs/reference/rest/v1/projects.locations.entryGroups.entries#Entry
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_id", "entry_group_id", "entry_configuration"}
+        | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogEntryLink(),)
+
+    def __init__(
+        self,
+        entry_id: str,
+        entry_group_id: str,
+        entry_configuration: Entry | dict,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_id = entry_id
+        self.entry_group_id = entry_group_id
+        self.entry_configuration = entry_configuration
+
+    def _validate_fields(self, entry_configuration):
+        required_fields = ["name", "entry_type"]
+
+        missing_fields = [field for field in required_fields if not entry_configuration.get(field)]
+
+        if missing_fields:
+            raise AirflowException(
+                f"Missing required fields in Entry configuration: {', '.join(missing_fields)}. "
+            )
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryLink.persist(
+            context=context,
+            task_instance=self,
+        )
+
+        self._validate_fields(self.entry_configuration)
+        try:
+            entry = self.hook.create_entry(
+                entry_id=self.entry_id,
+                entry_group_id=self.entry_group_id,
+                entry_configuration=self.entry_configuration,
+                location=self.location,
+                project_id=self.project_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+        except AlreadyExists:
+            entry = self.hook.get_entry(
+                entry_id=self.entry_id,
+                entry_group_id=self.entry_group_id,
+                location=self.location,
+                project_id=self.project_id,
+            )
+            self.log.info(
+                "Dataplex Catalog Entry %s already exists.",
+                self.entry_id,
+            )
+            result = Entry.to_dict(entry)
+            return result
+        except Exception as ex:
+            raise AirflowException(ex)
+        else:
+            result = Entry.to_dict(entry)
+
+        self.log.info("Dataplex Catalog Entry %s was successfully created.", self.entry_id)
+        return result
+
+
+class DataplexCatalogGetEntryOperator(DataplexCatalogBaseOperator):
+    """
+    Get an Entry resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogGetEntryOperator`
+
+    :param entry_id: Required. Entry identifier. It has to be unique within an Entry Group.
+        Entries corresponding to Google Cloud resources use an Entry ID format based on `full resource
+        names <https://cloud.google.com/apis/design/resource_names#full_resource_name>`__.
+        The format is a full resource name of the resource without the prefix double slashes in the API
+        service name part of the full resource name. This allows retrieval of entries using their associated
+        resource name.
+        For example, if the full resource name of a resource is
+        ``//library.googleapis.com/shelves/shelf1/books/book2``, then the suggested entry_id is
+        ``library.googleapis.com/shelves/shelf1/books/book2``.
+        It is also suggested to follow the same convention for entries corresponding to resources from
+        providers or systems other than Google Cloud.
+        The maximum size of the field is 4000 characters.
+    :param entry_group_id: Required. EntryGroup resource name to which created Entry will belong to.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param view: Optional. View to control which parts of an Entry the service should return.
+    :param aspect_types: Optional. Limits the aspects returned to the provided aspect types. It only works
+        for CUSTOM view.
+    :param paths: Optional. Limits the aspects returned to those associated with the provided paths within
+        the Entry. It only works for CUSTOM view.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_id", "entry_group_id"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogEntryLink(),)
+
+    def __init__(
+        self,
+        entry_id: str,
+        entry_group_id: str,
+        view: EntryView | str | None = None,
+        aspect_types: MutableSequence[str] | None = None,
+        paths: MutableSequence[str] | None = None,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_id = entry_id
+        self.entry_group_id = entry_group_id
+        self.view = view
+        self.aspect_types = aspect_types
+        self.paths = paths
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryLink.persist(
+            context=context,
+            task_instance=self,
+        )
+        self.log.info(
+            "Retrieving Dataplex Catalog Entry %s.",
+            self.entry_id,
+        )
+        try:
+            entry = self.hook.get_entry(
+                entry_id=self.entry_id,
+                entry_group_id=self.entry_group_id,
+                view=self.view,
+                aspect_types=self.aspect_types,
+                paths=self.paths,
+                location=self.location,
+                project_id=self.project_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+        except NotFound:
+            self.log.info(
+                "Dataplex Catalog Entry %s not found.",
+                self.entry_id,
+            )
+            raise AirflowException(NotFound)
+        except Exception as ex:
+            raise AirflowException(ex)
+
+        return Entry.to_dict(entry)
+
+
+class DataplexCatalogListEntriesOperator(DataplexCatalogBaseOperator):
+    r"""
+    List Entry resources.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogListEntriesOperator`
+
+    :param entry_group_id: Required. EntryGroup resource name to which created Entry belongs to.
+    :param filter_by: Optional. A filter on the entries to return. Filters are case-sensitive.
+        You can filter the request by the following fields:
+
+        -  entry_type
+        -  entry_source.display_name
+
+        The comparison operators are =, !=, <, >, <=, >=. The service compares strings according to
+        lexical order.
+        You can use the logical operators AND, OR, NOT in the filter. You can use Wildcard "*", but for
+        entry_type you need to provide the full project id or number.
+        Example filter expressions:
+
+        - "entry_source.display_name=AnExampleDisplayName"
+        - "entry_type=projects/example-project/locations/global/entryTypes/example-entry_type"
+        - "entry_type=projects/example-project/locations/us/entryTypes/a\*
+           OR entry_type=projects/another-project/locations/\*"
+        - "NOT entry_source.display_name=AnotherExampleDisplayName".
+
+    :param page_size: Optional. Number of items to return per page. If there are remaining results,
+        the service returns a next_page_token. If unspecified, the service returns at most 10 Entries.
+        The maximum value is 100; values above 100 will be coerced to 100.
+    :param page_token: Optional. Page token received from a previous ``ListEntries`` call. Provide
+        this to retrieve the subsequent page.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(DataplexCatalogBaseOperator.template_fields)
+    operator_extra_links = (DataplexCatalogEntryGroupLink(),)
+
+    def __init__(
+        self,
+        entry_group_id: str,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        filter_by: str | None = None,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_group_id = entry_group_id
+        self.page_size = page_size
+        self.page_token = page_token
+        self.filter_by = filter_by
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryGroupLink.persist(
+            context=context,
+            task_instance=self,
+        )
+        self.log.info(
+            "Listing Dataplex Catalog Entry from location %s.",
+            self.location,
+        )
+        try:
+            entries_on_page = self.hook.list_entries(
+                entry_group_id=self.entry_group_id,
+                location=self.location,
+                project_id=self.project_id,
+                page_size=self.page_size,
+                page_token=self.page_token,
+                filter_by=self.filter_by,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            self.log.info("Entries on page: %s", entries_on_page)
+            self.xcom_push(
+                context=context,
+                key="entry_page",
+                value=ListEntriesResponse.to_dict(entries_on_page._response),
+            )
+        except Exception as ex:
+            raise AirflowException(ex)
+
+        # Constructing list to return Entries in readable format
+        entries_list = [
+            MessageToDict(entry._pb, preserving_proto_field_name=True)
+            for entry in next(iter(entries_on_page.pages)).entries
+        ]
+        return entries_list
+
+
+class DataplexCatalogSearchEntriesOperator(DataplexCatalogBaseOperator):
+    """
+    Search for Entries matching the given query and scope.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogSearchEntriesOperator`
+
+    :param query: Required. The query against which entries in scope should be matched. The query
+        syntax is defined in `Search syntax for Dataplex Catalog
+        <https://cloud.google.com/dataplex/docs/search-syntax>`__.
+    :param order_by: Optional. Specifies the ordering of results. Supported values are:
+
+        - ``relevance`` (default)
+        - ``last_modified_timestamp``
+        - ``last_modified_timestamp asc``
+
+    :param scope: Optional. The scope under which the search should be operating. It must either be
+        ``organizations/<org_id>`` or ``projects/<project_ref>``. If it is unspecified, it
+        defaults to the organization where the project provided in ``name`` is located.
+    :param page_size: Optional. Number of items to return per page. If there are remaining results,
+        the service returns a next_page_token. If unspecified, the service returns at most 10 Entries.
+        The maximum value is 100; values above 100 will be coerced to 100.
+    :param page_token: Optional. Page token received from a previous ``ListEntries`` call. Provide
+        this to retrieve the subsequent page.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple({"query"} | set(DataplexCatalogBaseOperator.template_fields))
+
+    def __init__(
+        self,
+        query: str,
+        order_by: str | None = None,
+        scope: str | None = None,
+        page_size: int | None = None,
+        page_token: str | None = None,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.query = query
+        self.page_size = page_size
+        self.page_token = page_token
+        self.order_by = order_by
+        self.scope = scope
+
+    def execute(self, context: Context):
+        self.log.info(
+            "Listing Entries from location %s matching the given query %s and scope %s.",
+            self.location,
+            self.query,
+            self.scope,
+        )
+        try:
+            entries_on_page = self.hook.search_entries(
+                query=self.query,
+                location=self.location,
+                project_id=self.project_id,
+                page_size=self.page_size,
+                page_token=self.page_token,
+                order_by=self.order_by,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+            self.log.info("Entries on page: %s", entries_on_page)
+            self.xcom_push(
+                context=context,
+                key="entry_page",
+                value=SearchEntriesResponse.to_dict(entries_on_page._response),
+            )
+        except Exception as ex:
+            raise AirflowException(ex)
+
+        # Constructing list to return Entries in readable format
+        entries_list = [
+            MessageToDict(entry._pb, preserving_proto_field_name=True)
+            for entry in next(iter(entries_on_page.pages)).results
+        ]
+        return entries_list
+
+
+class DataplexCatalogLookupEntryOperator(DataplexCatalogBaseOperator):
+    """
+    Look up a single Entry by name using the permission on the source system.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogLookupEntryOperator`
+
+    :param entry_id: Required. Entry identifier. It has to be unique within an Entry Group.
+        Entries corresponding to Google Cloud resources use an Entry ID format based on `full resource
+        names <https://cloud.google.com/apis/design/resource_names#full_resource_name>`__.
+        The format is a full resource name of the resource without the prefix double slashes in the API
+        service name part of the full resource name. This allows retrieval of entries using their associated
+        resource name.
+        For example, if the full resource name of a resource is
+        ``//library.googleapis.com/shelves/shelf1/books/book2``, then the suggested entry_id is
+        ``library.googleapis.com/shelves/shelf1/books/book2``.
+        It is also suggested to follow the same convention for entries corresponding to resources from
+        providers or systems other than Google Cloud.
+        The maximum size of the field is 4000 characters.
+    :param entry_group_id: Required. EntryGroup resource name to which created Entry will belong to.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param view: Optional. View to control which parts of an Entry the service should return.
+    :param aspect_types: Optional. Limits the aspects returned to the provided aspect types. It only works
+        for CUSTOM view.
+    :param paths: Optional. Limits the aspects returned to those associated with the provided paths within
+        the Entry. It only works for CUSTOM view.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_id", "entry_group_id"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogEntryLink(),)
+
+    def __init__(
+        self,
+        entry_id: str,
+        entry_group_id: str,
+        view: EntryView | str | None = None,
+        aspect_types: MutableSequence[str] | None = None,
+        paths: MutableSequence[str] | None = None,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_id = entry_id
+        self.entry_group_id = entry_group_id
+        self.view = view
+        self.aspect_types = aspect_types
+        self.paths = paths
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryLink.persist(
+            context=context,
+            task_instance=self,
+        )
+        self.log.info(
+            "Looking for Dataplex Catalog Entry %s.",
+            self.entry_id,
+        )
+        try:
+            entry = self.hook.lookup_entry(
+                entry_id=self.entry_id,
+                entry_group_id=self.entry_group_id,
+                view=self.view,
+                aspect_types=self.aspect_types,
+                paths=self.paths,
+                location=self.location,
+                project_id=self.project_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+        except NotFound:
+            self.log.info(
+                "Dataplex Catalog Entry %s not found.",
+                self.entry_id,
+            )
+            raise AirflowException(NotFound)
+        except Exception as ex:
+            raise AirflowException(ex)
+
+        return Entry.to_dict(entry)
+
+
+class DataplexCatalogUpdateEntryOperator(DataplexCatalogBaseOperator):
+    """
+    Update an Entry resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogUpdateEntryOperator`
+
+    :param project_id: Required. The ID of the Google Cloud project that the task belongs to.
+    :param location: Required. The ID of the Google Cloud region that the task belongs to.
+    :param entry_id: Required. Entry identifier. It has to be unique within an Entry Group.
+        Entries corresponding to Google Cloud resources use an Entry ID format based on `full resource
+        names <https://cloud.google.com/apis/design/resource_names#full_resource_name>`__.
+        The format is a full resource name of the resource without the prefix double slashes in the API
+        service name part of the full resource name. This allows retrieval of entries using their
+        associated resource name.
+        For example, if the full resource name of a resource is
+        ``//library.googleapis.com/shelves/shelf1/books/book2``, then the suggested entry_id is
+        ``library.googleapis.com/shelves/shelf1/books/book2``.
+        It is also suggested to follow the same convention for entries corresponding to resources from
+        providers or systems other than Google Cloud.
+        The maximum size of the field is 4000 characters.
+    :param entry_group_id: Required. EntryGroup resource name to which created Entry belongs to.
+    :param entry_configuration: Required. The updated configuration body of the Entry.
+    :param allow_missing: Optional. If set to true and entry doesn't exist, the service will create it.
+    :param delete_missing_aspects: Optional. If set to true and the aspect_keys specify aspect
+        ranges, the service deletes any existing aspects from that range that weren't provided
+        in the request.
+    :param aspect_keys: Optional. The map keys of the Aspects which the service should modify.
+        It supports the following syntax:
+
+        - ``<aspect_type_reference>`` - matches an aspect of the given type and empty path.
+        - ``<aspect_type_reference>@path`` - matches an aspect of the given type and specified path.
+            For example, to attach an aspect to a field that is specified by the ``schema``
+            aspect, the path should have the format ``Schema.<field_name>``.
+        - ``<aspect_type_reference>@*`` - matches aspects of the given type for all paths.
+        - ``*@path`` - matches aspects of all types on the given path.
+
+        The service will not remove existing aspects matching the syntax unless ``delete_missing_aspects``
+        is set to true.
+        If this field is left empty, the service treats it as specifying exactly those Aspects present
+        in the request.
+    :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+        will not be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param gcp_conn_id: Optional. The connection ID to use when fetching connection info.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_id", "entry_group_id", "entry_configuration"}
+        | set(DataplexCatalogBaseOperator.template_fields)
+    )
+    operator_extra_links = (DataplexCatalogEntryLink(),)
+
+    def __init__(
+        self,
+        entry_id: str,
+        entry_group_id: str,
+        entry_configuration: dict | Entry,
+        allow_missing: bool | None = False,
+        delete_missing_aspects: bool | None = False,
+        aspect_keys: MutableSequence[str] | None = None,
+        update_mask: list[str] | FieldMask | None = None,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_id = entry_id
+        self.entry_group_id = entry_group_id
+        self.entry_configuration = entry_configuration
+        self.update_mask = update_mask
+        self.allow_missing = allow_missing
+        self.delete_missing_aspects = delete_missing_aspects
+        self.aspect_keys = aspect_keys
+
+    def execute(self, context: Context):
+        DataplexCatalogEntryLink.persist(
+            context=context,
+            task_instance=self,
+        )
+
+        try:
+            entry = self.hook.update_entry(
+                location=self.location,
+                project_id=self.project_id,
+                entry_id=self.entry_id,
+                entry_group_id=self.entry_group_id,
+                entry_configuration=self.entry_configuration,
+                update_mask=self.update_mask,
+                allow_missing=self.allow_missing,
+                delete_missing_aspects=self.delete_missing_aspects,
+                aspect_keys=self.aspect_keys,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+
+        except NotFound as ex:
+            self.log.info("Specified Entry was not found.")
+            raise AirflowException(ex)
+        except Exception as exc:
+            raise AirflowException(exc)
+        else:
+            result = Entry.to_dict(entry)
+        self.log.info("Entry %s was successfully updated.", self.entry_id)
+        return result
+
+
+class DataplexCatalogDeleteEntryOperator(DataplexCatalogBaseOperator):
+    """
+    Delete an Entry resource.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:DataplexCatalogDeleteEntryOperator`
+
+    :param entry_id: Required. Entry identifier. It has to be unique within an Entry Group.
+        Entries corresponding to Google Cloud resources use an Entry ID format based on `full resource
+        names <https://cloud.google.com/apis/design/resource_names#full_resource_name>`__.
+        The format is a full resource name of the resource without the prefix double slashes in the API
+        service name part of the full resource name. This allows retrieval of entries using their
+        associated resource name.
+        For example, if the full resource name of a resource is
+        ``//library.googleapis.com/shelves/shelf1/books/book2``, then the suggested entry_id is
+        ``library.googleapis.com/shelves/shelf1/books/book2``.
+        It is also suggested to follow the same convention for entries corresponding to resources from
+        providers or systems other than Google Cloud.
+        The maximum size of the field is 4000 characters.
+    :param entry_group_id: Required. EntryGroup resource name to which created Entry will belong to.
+    :param project_id: Required. The ID of the Google Cloud project where the service is used.
+    :param location: Required. The ID of the Google Cloud region where the service is used.
+    :param gcp_conn_id: Optional. The connection ID to use to connect to Google Cloud.
+    :param retry: Optional. A retry object used to retry requests. If `None` is specified, requests will not
+        be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param metadata: Optional. Additional metadata that is provided to the method.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    template_fields: Sequence[str] = tuple(
+        {"entry_id", "entry_group_id"} | set(DataplexCatalogBaseOperator.template_fields)
+    )
+
+    def __init__(
+        self,
+        entry_id: str,
+        entry_group_id: str,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.entry_id = entry_id
+        self.entry_group_id = entry_group_id
+
+    def execute(self, context: Context):
+        self.log.info(
+            "Deleting Dataplex Catalog Entry %s.",
+            self.entry_id,
+        )
+        try:
+            entry = self.hook.delete_entry(
+                entry_id=self.entry_id,
+                entry_group_id=self.entry_group_id,
+                location=self.location,
+                project_id=self.project_id,
+                retry=self.retry,
+                timeout=self.timeout,
+                metadata=self.metadata,
+            )
+
+        except NotFound:
+            self.log.info(
+                "Dataplex Catalog Entry %s not found.",
+                self.entry_id,
+            )
+            raise AirflowException(NotFound)
+        except Exception as ex:
+            raise AirflowException(ex)
+        return Entry.to_dict(entry)