openmeter 1.0.0b121__py3-none-any.whl → 1.0.0b122__py3-none-any.whl

openmeter/_operations/_operations.py

@@ -797,6 +797,280 @@ def build_get_debug_metrics_request(**kwargs: Any) -> HttpRequest:
     return HttpRequest(method="GET", url=_url, headers=_headers, **kwargs)
 
 
+def build_list_notification_channels_request(
+    *, limit: int = 1000, offset: int = 0, order_by: str = "id", include_disabled: bool = False, **kwargs: Any
+) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+    _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+
+    accept = _headers.pop("Accept", "application/json, application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/channels"
+
+    # Construct parameters
+    if limit is not None:
+        _params["limit"] = _SERIALIZER.query("limit", limit, "int", maximum=1000, minimum=1)
+    if offset is not None:
+        _params["offset"] = _SERIALIZER.query("offset", offset, "int", minimum=0)
+    if order_by is not None:
+        _params["orderBy"] = _SERIALIZER.query("order_by", order_by, "str")
+    if include_disabled is not None:
+        _params["includeDisabled"] = _SERIALIZER.query("include_disabled", include_disabled, "bool")
+
+    # Construct headers
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
+
+
+def build_create_notification_channel_request(**kwargs: Any) -> HttpRequest:  # pylint: disable=name-too-long
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+
+    content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    accept = _headers.pop("Accept", "application/json, application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/channels"
+
+    # Construct headers
+    if content_type is not None:
+        _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="POST", url=_url, headers=_headers, **kwargs)
+
+
+def build_get_notification_channel_request(channel_id: str, **kwargs: Any) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+
+    accept = _headers.pop("Accept", "application/json, application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/channels/{channelId}"
+    path_format_arguments = {
+        "channelId": _SERIALIZER.url("channel_id", channel_id, "str"),
+    }
+
+    _url: str = _url.format(**path_format_arguments)  # type: ignore
+
+    # Construct headers
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="GET", url=_url, headers=_headers, **kwargs)
+
+
+def build_delete_notification_channel_request(  # pylint: disable=name-too-long
+    channel_id: str, **kwargs: Any
+) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+
+    accept = _headers.pop("Accept", "application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/channels/{channelId}"
+    path_format_arguments = {
+        "channelId": _SERIALIZER.url("channel_id", channel_id, "str"),
+    }
+
+    _url: str = _url.format(**path_format_arguments)  # type: ignore
+
+    # Construct headers
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="DELETE", url=_url, headers=_headers, **kwargs)
+
+
+def build_update_notification_channel_request(  # pylint: disable=name-too-long
+    channel_id: str, **kwargs: Any
+) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+
+    content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    accept = _headers.pop("Accept", "application/json, application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/channels/{channelId}"
+    path_format_arguments = {
+        "channelId": _SERIALIZER.url("channel_id", channel_id, "str"),
+    }
+
+    _url: str = _url.format(**path_format_arguments)  # type: ignore
+
+    # Construct headers
+    if content_type is not None:
+        _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="PUT", url=_url, headers=_headers, **kwargs)
+
+
+def build_list_notification_rules_request(
+    *,
+    limit: int = 1000,
+    offset: int = 0,
+    order_by: str = "id",
+    include_disabled: bool = False,
+    feature: Optional[List[str]] = None,
+    **kwargs: Any
+) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+    _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+
+    accept = _headers.pop("Accept", "application/json, application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/rules"
+
+    # Construct parameters
+    if limit is not None:
+        _params["limit"] = _SERIALIZER.query("limit", limit, "int", maximum=1000, minimum=1)
+    if offset is not None:
+        _params["offset"] = _SERIALIZER.query("offset", offset, "int", minimum=0)
+    if order_by is not None:
+        _params["orderBy"] = _SERIALIZER.query("order_by", order_by, "str")
+    if include_disabled is not None:
+        _params["includeDisabled"] = _SERIALIZER.query("include_disabled", include_disabled, "bool")
+    if feature is not None:
+        _params["feature"] = _SERIALIZER.query("feature", feature, "[str]")
+
+    # Construct headers
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
+
+
+def build_create_notification_rule_request(**kwargs: Any) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+
+    content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    accept = _headers.pop("Accept", "application/json, application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/rules"
+
+    # Construct headers
+    if content_type is not None:
+        _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="POST", url=_url, headers=_headers, **kwargs)
+
+
+def build_get_notification_rule_request(rule_id: str, **kwargs: Any) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+
+    accept = _headers.pop("Accept", "application/json, application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/rules/{ruleId}"
+    path_format_arguments = {
+        "ruleId": _SERIALIZER.url("rule_id", rule_id, "str"),
+    }
+
+    _url: str = _url.format(**path_format_arguments)  # type: ignore
+
+    # Construct headers
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="GET", url=_url, headers=_headers, **kwargs)
+
+
+def build_delete_notification_rule_request(rule_id: str, **kwargs: Any) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+
+    accept = _headers.pop("Accept", "application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/rules/{ruleId}"
+    path_format_arguments = {
+        "ruleId": _SERIALIZER.url("rule_id", rule_id, "str"),
+    }
+
+    _url: str = _url.format(**path_format_arguments)  # type: ignore
+
+    # Construct headers
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="DELETE", url=_url, headers=_headers, **kwargs)
+
+
+def build_update_notification_rule_request(rule_id: str, **kwargs: Any) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+
+    content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    accept = _headers.pop("Accept", "application/json, application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/rules/{ruleId}"
+    path_format_arguments = {
+        "ruleId": _SERIALIZER.url("rule_id", rule_id, "str"),
+    }
+
+    _url: str = _url.format(**path_format_arguments)  # type: ignore
+
+    # Construct headers
+    if content_type is not None:
+        _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="PUT", url=_url, headers=_headers, **kwargs)
+
+
+def build_list_notification_events_request(
+    *,
+    limit: int = 1000,
+    offset: int = 0,
+    order_by: str = "id",
+    feature: Optional[List[str]] = None,
+    subject: Optional[List[str]] = None,
+    **kwargs: Any
+) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+    _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+
+    accept = _headers.pop("Accept", "application/json, application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/events"
+
+    # Construct parameters
+    if limit is not None:
+        _params["limit"] = _SERIALIZER.query("limit", limit, "int", maximum=1000, minimum=1)
+    if offset is not None:
+        _params["offset"] = _SERIALIZER.query("offset", offset, "int", minimum=0)
+    if order_by is not None:
+        _params["orderBy"] = _SERIALIZER.query("order_by", order_by, "str")
+    if feature is not None:
+        _params["feature"] = _SERIALIZER.query("feature", feature, "[str]")
+    if subject is not None:
+        _params["subject"] = _SERIALIZER.query("subject", subject, "[str]")
+
+    # Construct headers
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
+
+
+def build_get_notification_event_request(event_id: str, **kwargs: Any) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+
+    accept = _headers.pop("Accept", "application/json, application/problem+json")
+
+    # Construct URL
+    _url = "/api/v1/notification/events/{eventId}"
+    path_format_arguments = {
+        "eventId": _SERIALIZER.url("event_id", event_id, "str"),
+    }
+
+    _url: str = _url.format(**path_format_arguments)  # type: ignore
+
+    # Construct headers
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="GET", url=_url, headers=_headers, **kwargs)
+
+
 class ClientOperationsMixin(ClientMixinABC):  # pylint: disable=too-many-public-methods
     @distributed_trace
     def list_events(
@@ -1573,7 +1847,7 @@ class ClientOperationsMixin(ClientMixinABC):  # pylint: disable=too-many-public-
         :paramtype window_time_zone: str
         :keyword subject: Filtering by multiple subjects.
 
-         Usage: ?subject=customer-1&subject=customer-2. Default value is None.
+         Usage: ``?subject=customer-1&subject=customer-2``. Default value is None.
         :paramtype subject: list[str]
         :keyword filter_group_by: Default value is None.
         :paramtype filter_group_by: dict[str, str]
@@ -4966,3 +5240,1147 @@ class ClientOperationsMixin(ClientMixinABC):  # pylint: disable=too-many-public-
             return cls(pipeline_response, cast(str, deserialized), {})  # type: ignore
 
         return cast(str, deserialized)  # type: ignore
+
+    @distributed_trace
+    def list_notification_channels(
+        self, *, limit: int = 1000, offset: int = 0, order_by: str = "id", include_disabled: bool = False, **kwargs: Any
+    ) -> List[JSON]:
+        """List notification channels.
+
+        List all notification channels.
+
+        :keyword limit: Number of entries to return. Default value is 1000.
+        :paramtype limit: int
+        :keyword offset: Number of entries to skip. Default value is 0.
+        :paramtype offset: int
+        :keyword order_by: Order by field. Known values are: "id", "type", "createdAt", and
+         "updatedAt". Default value is "id".
+        :paramtype order_by: str
+        :keyword include_disabled: Include disabled entries. Default value is False.
+        :paramtype include_disabled: bool
+        :return: list of JSON object
+        :rtype: list[JSON]
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # response body for status code(s): 200
+                response == [
+                    {}
+                ]
+        """
+        error_map = {
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            400: HttpResponseError,
+            401: lambda response: ClientAuthenticationError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[List[JSON]] = kwargs.pop("cls", None)
+
+        _request = build_list_notification_channels_request(
+            limit=limit,
+            offset=offset,
+            order_by=order_by,
+            include_disabled=include_disabled,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if response.content:
+            deserialized = response.json()
+        else:
+            deserialized = None
+
+        if cls:
+            return cls(pipeline_response, cast(List[JSON], deserialized), {})  # type: ignore
+
+        return cast(List[JSON], deserialized)  # type: ignore
+
+    @overload
+    def create_notification_channel(self, body: JSON, *, content_type: str = "application/json", **kwargs: Any) -> JSON:
+        """Create a notification channel.
+
+        Create a new notification channel.
+
+        :param body: The notification channel to create. Required.
+        :type body: JSON
+        :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                body = {}
+
+                # response body for status code(s): 409
+                response == {
+                    "detail": "str",  # A human-readable explanation specific to this occurrence
+                      of the problem. Required.
+                    "status": 0,  # The HTTP status code generated by the origin server for this
+                      occurrence of the problem. Required.
+                    "title": "str",  # A a short, human-readable summary of the problem type.
+                      Required.
+                    "type": "str",  # Type contains a URI that identifies the problem type.
+                      Required.
+                    "extensions": {
+                        "conflictingEntityId": "str"  # The id of the conflicting entity.
+                          Required.
+                    },
+                    "instance": "str"  # Optional. A URI reference that identifies the specific
+                      occurrence of the problem.
+                }
+        """
+
+    @overload
+    def create_notification_channel(
+        self, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
+    ) -> JSON:
+        """Create a notification channel.
+
+        Create a new notification channel.
+
+        :param body: The notification channel to create. Required.
+        :type body: IO[bytes]
+        :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # response body for status code(s): 409
+                response == {
+                    "detail": "str",  # A human-readable explanation specific to this occurrence
+                      of the problem. Required.
+                    "status": 0,  # The HTTP status code generated by the origin server for this
+                      occurrence of the problem. Required.
+                    "title": "str",  # A a short, human-readable summary of the problem type.
+                      Required.
+                    "type": "str",  # Type contains a URI that identifies the problem type.
+                      Required.
+                    "extensions": {
+                        "conflictingEntityId": "str"  # The id of the conflicting entity.
+                          Required.
+                    },
+                    "instance": "str"  # Optional. A URI reference that identifies the specific
+                      occurrence of the problem.
+                }
+        """
+
+    @distributed_trace
+    def create_notification_channel(self, body: Union[JSON, IO[bytes]], **kwargs: Any) -> JSON:
+        """Create a notification channel.
+
+        Create a new notification channel.
+
+        :param body: The notification channel to create. Is either a JSON type or a IO[bytes] type.
+         Required.
+        :type body: JSON or IO[bytes]
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                body = {}
+
+                # response body for status code(s): 409
+                response == {
+                    "detail": "str",  # A human-readable explanation specific to this occurrence
+                      of the problem. Required.
+                    "status": 0,  # The HTTP status code generated by the origin server for this
+                      occurrence of the problem. Required.
+                    "title": "str",  # A a short, human-readable summary of the problem type.
+                      Required.
+                    "type": "str",  # Type contains a URI that identifies the problem type.
+                      Required.
+                    "extensions": {
+                        "conflictingEntityId": "str"  # The id of the conflicting entity.
+                          Required.
+                    },
+                    "instance": "str"  # Optional. A URI reference that identifies the specific
+                      occurrence of the problem.
+                }
+        """
+        error_map = {
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            400: HttpResponseError,
+            401: lambda response: ClientAuthenticationError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
+
+        content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+        cls: ClsType[JSON] = kwargs.pop("cls", None)
+
+        content_type = content_type or "application/json"
+        _json = None
+        _content = None
+        if isinstance(body, (IOBase, bytes)):
+            _content = body
+        else:
+            _json = body
+
+        _request = build_create_notification_channel_request(
+            content_type=content_type,
+            json=_json,
+            content=_content,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [201, 409]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if response.status_code == 201:
+            if response.content:
+                deserialized = response.json()
+            else:
+                deserialized = None
+
+        if response.status_code == 409:
+            if response.content:
+                deserialized = response.json()
+            else:
+                deserialized = None
+
+        if cls:
+            return cls(pipeline_response, cast(JSON, deserialized), {})  # type: ignore
+
+        return cast(JSON, deserialized)  # type: ignore
+
+    @distributed_trace
+    def get_notification_channel(self, channel_id: str, **kwargs: Any) -> JSON:
+        """Get notification channel.
+
+        Get a notification channel by id.
+
+        :param channel_id: A unique ULID identifier for a notification channel. Required.
+        :type channel_id: str
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        error_map = {
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            401: lambda response: ClientAuthenticationError(response=response),
+            404: lambda response: ResourceNotFoundError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[JSON] = kwargs.pop("cls", None)
+
+        _request = build_get_notification_channel_request(
+            channel_id=channel_id,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if response.content:
+            deserialized = response.json()
+        else:
+            deserialized = None
+
+        if cls:
+            return cls(pipeline_response, cast(JSON, deserialized), {})  # type: ignore
+
+        return cast(JSON, deserialized)  # type: ignore
+
+    @distributed_trace
+    def delete_notification_channel(  # pylint: disable=inconsistent-return-statements
+        self, channel_id: str, **kwargs: Any
+    ) -> None:
+        """Delete a notification channel.
+
+        Delete notification channel by id.
+
+        :param channel_id: A unique ULID identifier for a notification channel. Required.
+        :type channel_id: str
+        :return: None
+        :rtype: None
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        error_map = {
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            401: lambda response: ClientAuthenticationError(response=response),
+            404: lambda response: ResourceNotFoundError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[None] = kwargs.pop("cls", None)
+
+        _request = build_delete_notification_channel_request(
+            channel_id=channel_id,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [204]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if cls:
+            return cls(pipeline_response, None, {})  # type: ignore
+
+    @overload
+    def update_notification_channel(
+        self, channel_id: str, body: JSON, *, content_type: str = "application/json", **kwargs: Any
+    ) -> JSON:
+        """Update notification channel.
+
+        Update a notification channel by id.
+
+        :param channel_id: A unique ULID identifier for a notification channel. Required.
+        :type channel_id: str
+        :param body: The notification channel to update. Required.
+        :type body: JSON
+        :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                body = {}
+        """
+
+    @overload
+    def update_notification_channel(
+        self, channel_id: str, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
+    ) -> JSON:
+        """Update notification channel.
+
+        Update a notification channel by id.
+
+        :param channel_id: A unique ULID identifier for a notification channel. Required.
+        :type channel_id: str
+        :param body: The notification channel to update. Required.
+        :type body: IO[bytes]
+        :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+
+    @distributed_trace
+    def update_notification_channel(self, channel_id: str, body: Union[JSON, IO[bytes]], **kwargs: Any) -> JSON:
+        """Update notification channel.
+
+        Update a notification channel by id.
+
+        :param channel_id: A unique ULID identifier for a notification channel. Required.
+        :type channel_id: str
+        :param body: The notification channel to update. Is either a JSON type or a IO[bytes] type.
+         Required.
+        :type body: JSON or IO[bytes]
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                body = {}
+        """
+        error_map = {
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            401: lambda response: ClientAuthenticationError(response=response),
+            404: lambda response: ResourceNotFoundError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
+
+        content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+        cls: ClsType[JSON] = kwargs.pop("cls", None)
+
+        content_type = content_type or "application/json"
+        _json = None
+        _content = None
+        if isinstance(body, (IOBase, bytes)):
+            _content = body
+        else:
+            _json = body
+
+        _request = build_update_notification_channel_request(
+            channel_id=channel_id,
+            content_type=content_type,
+            json=_json,
+            content=_content,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if response.content:
+            deserialized = response.json()
+        else:
+            deserialized = None
+
+        if cls:
+            return cls(pipeline_response, cast(JSON, deserialized), {})  # type: ignore
+
+        return cast(JSON, deserialized)  # type: ignore
+
+    @distributed_trace
+    def list_notification_rules(
+        self,
+        *,
+        limit: int = 1000,
+        offset: int = 0,
+        order_by: str = "id",
+        include_disabled: bool = False,
+        feature: Optional[List[str]] = None,
+        **kwargs: Any
+    ) -> List[JSON]:
+        """List notification rules.
+
+        List all notification rules.
+
+        :keyword limit: Number of entries to return. Default value is 1000.
+        :paramtype limit: int
+        :keyword offset: Number of entries to skip. Default value is 0.
+        :paramtype offset: int
+        :keyword order_by: Order by field. Known values are: "id", "type", "createdAt", and
+         "updatedAt". Default value is "id".
+        :paramtype order_by: str
+        :keyword include_disabled: Include disabled entries. Default value is False.
+        :paramtype include_disabled: bool
+        :keyword feature: Filtering by multiple features.
+
+         Usage: ``?feature=feature-1&feature=feature-2``. Default value is None.
+        :paramtype feature: list[str]
+        :return: list of JSON object
+        :rtype: list[JSON]
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # response body for status code(s): 200
+                response == [
+                    {}
+                ]
+        """
+        error_map = {
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            400: HttpResponseError,
+            401: lambda response: ClientAuthenticationError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[List[JSON]] = kwargs.pop("cls", None)
+
+        _request = build_list_notification_rules_request(
+            limit=limit,
+            offset=offset,
+            order_by=order_by,
+            include_disabled=include_disabled,
+            feature=feature,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if response.content:
+            deserialized = response.json()
+        else:
+            deserialized = None
+
+        if cls:
+            return cls(pipeline_response, cast(List[JSON], deserialized), {})  # type: ignore
+
+        return cast(List[JSON], deserialized)  # type: ignore
+
+    @overload
+    def create_notification_rule(self, body: JSON, *, content_type: str = "application/json", **kwargs: Any) -> JSON:
+        """Create a notification rule.
+
+        Create a new notification rule.
+
+        :param body: The notification rule to create. Required.
+        :type body: JSON
+        :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                body = {}
+
+                # response body for status code(s): 409
+                response == {
+                    "detail": "str",  # A human-readable explanation specific to this occurrence
+                      of the problem. Required.
+                    "status": 0,  # The HTTP status code generated by the origin server for this
+                      occurrence of the problem. Required.
+                    "title": "str",  # A a short, human-readable summary of the problem type.
+                      Required.
+                    "type": "str",  # Type contains a URI that identifies the problem type.
+                      Required.
+                    "extensions": {
+                        "conflictingEntityId": "str"  # The id of the conflicting entity.
+                          Required.
+                    },
+                    "instance": "str"  # Optional. A URI reference that identifies the specific
+                      occurrence of the problem.
+                }
+        """
+
+    @overload
+    def create_notification_rule(
+        self, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
+    ) -> JSON:
+        """Create a notification rule.
+
+        Create a new notification rule.
+
+        :param body: The notification rule to create. Required.
+        :type body: IO[bytes]
+        :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # response body for status code(s): 409
+                response == {
+                    "detail": "str",  # A human-readable explanation specific to this occurrence
+                      of the problem. Required.
+                    "status": 0,  # The HTTP status code generated by the origin server for this
+                      occurrence of the problem. Required.
+                    "title": "str",  # A a short, human-readable summary of the problem type.
+                      Required.
+                    "type": "str",  # Type contains a URI that identifies the problem type.
+                      Required.
+                    "extensions": {
+                        "conflictingEntityId": "str"  # The id of the conflicting entity.
+                          Required.
+                    },
+                    "instance": "str"  # Optional. A URI reference that identifies the specific
+                      occurrence of the problem.
+                }
+        """
+
+    @distributed_trace
+    def create_notification_rule(self, body: Union[JSON, IO[bytes]], **kwargs: Any) -> JSON:
+        """Create a notification rule.
+
+        Create a new notification rule.
+
+        :param body: The notification rule to create. Is either a JSON type or a IO[bytes] type.
+         Required.
+        :type body: JSON or IO[bytes]
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                body = {}
+
+                # response body for status code(s): 409
+                response == {
+                    "detail": "str",  # A human-readable explanation specific to this occurrence
+                      of the problem. Required.
+                    "status": 0,  # The HTTP status code generated by the origin server for this
+                      occurrence of the problem. Required.
+                    "title": "str",  # A a short, human-readable summary of the problem type.
+                      Required.
+                    "type": "str",  # Type contains a URI that identifies the problem type.
+                      Required.
+                    "extensions": {
+                        "conflictingEntityId": "str"  # The id of the conflicting entity.
+                          Required.
+                    },
+                    "instance": "str"  # Optional. A URI reference that identifies the specific
+                      occurrence of the problem.
+                }
+        """
+        error_map = {
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            400: HttpResponseError,
+            401: lambda response: ClientAuthenticationError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
+
+        content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+        cls: ClsType[JSON] = kwargs.pop("cls", None)
+
+        content_type = content_type or "application/json"
+        _json = None
+        _content = None
+        if isinstance(body, (IOBase, bytes)):
+            _content = body
+        else:
+            _json = body
+
+        _request = build_create_notification_rule_request(
+            content_type=content_type,
+            json=_json,
+            content=_content,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [201, 409]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if response.status_code == 201:
+            if response.content:
+                deserialized = response.json()
+            else:
+                deserialized = None
+
+        if response.status_code == 409:
+            if response.content:
+                deserialized = response.json()
+            else:
+                deserialized = None
+
+        if cls:
+            return cls(pipeline_response, cast(JSON, deserialized), {})  # type: ignore
+
+        return cast(JSON, deserialized)  # type: ignore
+
+    @distributed_trace
+    def get_notification_rule(self, rule_id: str, **kwargs: Any) -> JSON:
+        """Get notification rule.
+
+        Get a notification rule by id.
+
+        :param rule_id: A unique ULID identifier for a notification rule. Required.
+        :type rule_id: str
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        error_map = {
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            401: lambda response: ClientAuthenticationError(response=response),
+            404: lambda response: ResourceNotFoundError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[JSON] = kwargs.pop("cls", None)
+
+        _request = build_get_notification_rule_request(
+            rule_id=rule_id,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if response.content:
+            deserialized = response.json()
+        else:
+            deserialized = None
+
+        if cls:
+            return cls(pipeline_response, cast(JSON, deserialized), {})  # type: ignore
+
+        return cast(JSON, deserialized)  # type: ignore
+
+    @distributed_trace
+    def delete_notification_rule(  # pylint: disable=inconsistent-return-statements
+        self, rule_id: str, **kwargs: Any
+    ) -> None:
+        """Delete a notification rule.
+
+        Delete notification rule by id.
+
+        :param rule_id: A unique ULID identifier for a notification rule. Required.
+        :type rule_id: str
+        :return: None
+        :rtype: None
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        error_map = {
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            401: lambda response: ClientAuthenticationError(response=response),
+            404: lambda response: ResourceNotFoundError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[None] = kwargs.pop("cls", None)
+
+        _request = build_delete_notification_rule_request(
+            rule_id=rule_id,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [204]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if cls:
+            return cls(pipeline_response, None, {})  # type: ignore
+
+    @overload
+    def update_notification_rule(
+        self, rule_id: str, body: JSON, *, content_type: str = "application/json", **kwargs: Any
+    ) -> JSON:
+        """Update a notification rule.
+
+        Update a notification rule by id.
+
+        :param rule_id: A unique ULID identifier for a notification rule. Required.
+        :type rule_id: str
+        :param body: The notification rule to update. Required.
+        :type body: JSON
+        :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                body = {}
+        """
+
+    @overload
+    def update_notification_rule(
+        self, rule_id: str, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
+    ) -> JSON:
+        """Update a notification rule.
+
+        Update a notification rule by id.
+
+        :param rule_id: A unique ULID identifier for a notification rule. Required.
+        :type rule_id: str
+        :param body: The notification rule to update. Required.
+        :type body: IO[bytes]
+        :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+
+    @distributed_trace
+    def update_notification_rule(self, rule_id: str, body: Union[JSON, IO[bytes]], **kwargs: Any) -> JSON:
+        """Update a notification rule.
+
+        Update a notification rule by id.
+
+        :param rule_id: A unique ULID identifier for a notification rule. Required.
+        :type rule_id: str
+        :param body: The notification rule to update. Is either a JSON type or a IO[bytes] type.
+         Required.
+        :type body: JSON or IO[bytes]
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # JSON input template you can fill out and use as your body input.
+                body = {}
+        """
+        error_map = {
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            401: lambda response: ClientAuthenticationError(response=response),
+            404: lambda response: ResourceNotFoundError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
+
+        content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+        cls: ClsType[JSON] = kwargs.pop("cls", None)
+
+        content_type = content_type or "application/json"
+        _json = None
+        _content = None
+        if isinstance(body, (IOBase, bytes)):
+            _content = body
+        else:
+            _json = body
+
+        _request = build_update_notification_rule_request(
+            rule_id=rule_id,
+            content_type=content_type,
+            json=_json,
+            content=_content,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if response.content:
+            deserialized = response.json()
+        else:
+            deserialized = None
+
+        if cls:
+            return cls(pipeline_response, cast(JSON, deserialized), {})  # type: ignore
+
+        return cast(JSON, deserialized)  # type: ignore
+
+    @distributed_trace
+    def list_notification_events(
+        self,
+        *,
+        limit: int = 1000,
+        offset: int = 0,
+        order_by: str = "id",
+        feature: Optional[List[str]] = None,
+        subject: Optional[List[str]] = None,
+        **kwargs: Any
+    ) -> List[JSON]:
+        """List notification evens.
+
+        List all notification events.
+
+        :keyword limit: Number of entries to return. Default value is 1000.
+        :paramtype limit: int
+        :keyword offset: Number of entries to skip. Default value is 0.
+        :paramtype offset: int
+        :keyword order_by: Order by field. Known values are: "id" and "createdAt". Default value is
+         "id".
+        :paramtype order_by: str
+        :keyword feature: Filtering by multiple features.
+
+         Usage: ``?feature=feature-1&feature=feature-2``. Default value is None.
+        :paramtype feature: list[str]
+        :keyword subject: Filtering by multiple subjects.
+
+         Usage: ``?subject=customer-1&subject=customer-2``. Default value is None.
+        :paramtype subject: list[str]
+        :return: list of JSON object
+        :rtype: list[JSON]
+        :raises ~azure.core.exceptions.HttpResponseError:
+
+        Example:
+            .. code-block:: python
+
+                # response body for status code(s): 200
+                response == [
+                    {
+                        "createdAt": "2020-02-20 00:00:00",  # Timestamp when the
+                          notification event was created. Required.
+                        "deliveryStatus": [
+                            {
+                                "channel": {
+                                    "id": "str",  # A unique identifier for the
+                                      notification channel. Required.
+                                    "type": "str"  # The type of the notification
+                                      channel. Required. "WEBHOOK"
+                                },
+                                "state": "str",  # Required. Known values are:
+                                  "SUCCESS", "FAILED", and "SENDING".
+                                "updatedAt": "2020-02-20 00:00:00"  # Required.
+                            }
+                        ],
+                        "id": "str",  # A unique identifier for the notification event.
+                          Required.
+                        "payload": {},
+                        "rule": {
+                            "id": "str",  # A unique identifier for the notification
+                              rule. Required.
+                            "type": "str"  # The type of the notification event.
+                              Required. "entitlements.balance.threshold"
+                        }
+                    }
+                ]
+        """
+        error_map = {
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            400: HttpResponseError,
+            401: lambda response: ClientAuthenticationError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[List[JSON]] = kwargs.pop("cls", None)
+
+        _request = build_list_notification_events_request(
+            limit=limit,
+            offset=offset,
+            order_by=order_by,
+            feature=feature,
+            subject=subject,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if response.content:
+            deserialized = response.json()
+        else:
+            deserialized = None
+
+        if cls:
+            return cls(pipeline_response, cast(List[JSON], deserialized), {})  # type: ignore
+
+        return cast(List[JSON], deserialized)  # type: ignore
+
+    @distributed_trace
+    def get_notification_event(self, event_id: str, **kwargs: Any) -> JSON:
+        """Get notification event.
+
+        Get a notification event by id.
+
+        :param event_id: A unique ULID identifier for a notification event. Required.
+        :type event_id: str
+        :return: JSON object
+        :rtype: JSON
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        error_map = {
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+            401: lambda response: ClientAuthenticationError(response=response),
+            404: lambda response: ResourceNotFoundError(response=response),
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[JSON] = kwargs.pop("cls", None)
+
+        _request = build_get_notification_event_request(
+            event_id=event_id,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
+            _request, stream=_stream, **kwargs
+        )
+
+        response = pipeline_response.http_response
+
+        if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
+            map_error(status_code=response.status_code, response=response, error_map=error_map)  # type: ignore
+            raise HttpResponseError(response=response)
+
+        if response.content:
+            deserialized = response.json()
+        else:
+            deserialized = None
+
+        if cls:
+            return cls(pipeline_response, cast(JSON, deserialized), {})  # type: ignore
+
+        return cast(JSON, deserialized)  # type: ignore