openmeter 1.0.0b54__py3-none-any.whl → 2.0.0__py3-none-any.whl

openmeter/resources/subjects.py

@@ -0,0 +1,419 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+
+import httpx
+
+from ...types import subject_upsert_params
+from ..._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
+from ..._utils import (
+    maybe_transform,
+    async_maybe_transform,
+)
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .entitlements import (
+    EntitlementsResource,
+    AsyncEntitlementsResource,
+    EntitlementsResourceWithRawResponse,
+    AsyncEntitlementsResourceWithRawResponse,
+    EntitlementsResourceWithStreamingResponse,
+    AsyncEntitlementsResourceWithStreamingResponse,
+)
+from ..._base_client import make_request_options
+from ...types.subject import Subject
+from .entitlements.entitlements import EntitlementsResource, AsyncEntitlementsResource
+from ...types.subject_list_response import SubjectListResponse
+from ...types.subject_upsert_response import SubjectUpsertResponse
+
+__all__ = ["SubjectsResource", "AsyncSubjectsResource"]
+
+
+class SubjectsResource(SyncAPIResource):
+    @cached_property
+    def entitlements(self) -> EntitlementsResource:
+        return EntitlementsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> SubjectsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openmeterio/openmeter-python#accessing-raw-response-data-eg-headers
+        """
+        return SubjectsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SubjectsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openmeterio/openmeter-python#with_streaming_response
+        """
+        return SubjectsResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        subject_id_or_key: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Subject:
+        """
+        Get subject by ID or key.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not subject_id_or_key:
+            raise ValueError(f"Expected a non-empty value for `subject_id_or_key` but received {subject_id_or_key!r}")
+        return self._get(
+            f"/api/v1/subjects/{subject_id_or_key}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Subject,
+        )
+
+    def list(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SubjectListResponse:
+        """List subjects."""
+        return self._get(
+            "/api/v1/subjects",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SubjectListResponse,
+        )
+
+    def delete(
+        self,
+        subject_id_or_key: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> None:
+        """
+        Delete subject by ID or key.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not subject_id_or_key:
+            raise ValueError(f"Expected a non-empty value for `subject_id_or_key` but received {subject_id_or_key!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            f"/api/v1/subjects/{subject_id_or_key}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def upsert(
+        self,
+        *,
+        body: Iterable[subject_upsert_params.Body],
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SubjectUpsertResponse:
+        """Upserts a subject.
+
+        Creates or updates subject.
+
+        If the subject doesn't exist, it will be created. If the subject exists, it will
+        be partially updated with the provided fields.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/api/v1/subjects",
+            body=maybe_transform(body, Iterable[subject_upsert_params.Body]),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SubjectUpsertResponse,
+        )
+
+
+class AsyncSubjectsResource(AsyncAPIResource):
+    @cached_property
+    def entitlements(self) -> AsyncEntitlementsResource:
+        return AsyncEntitlementsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncSubjectsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openmeterio/openmeter-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncSubjectsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSubjectsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openmeterio/openmeter-python#with_streaming_response
+        """
+        return AsyncSubjectsResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        subject_id_or_key: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Subject:
+        """
+        Get subject by ID or key.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not subject_id_or_key:
+            raise ValueError(f"Expected a non-empty value for `subject_id_or_key` but received {subject_id_or_key!r}")
+        return await self._get(
+            f"/api/v1/subjects/{subject_id_or_key}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Subject,
+        )
+
+    async def list(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SubjectListResponse:
+        """List subjects."""
+        return await self._get(
+            "/api/v1/subjects",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SubjectListResponse,
+        )
+
+    async def delete(
+        self,
+        subject_id_or_key: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> None:
+        """
+        Delete subject by ID or key.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not subject_id_or_key:
+            raise ValueError(f"Expected a non-empty value for `subject_id_or_key` but received {subject_id_or_key!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            f"/api/v1/subjects/{subject_id_or_key}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    async def upsert(
+        self,
+        *,
+        body: Iterable[subject_upsert_params.Body],
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> SubjectUpsertResponse:
+        """Upserts a subject.
+
+        Creates or updates subject.
+
+        If the subject doesn't exist, it will be created. If the subject exists, it will
+        be partially updated with the provided fields.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/api/v1/subjects",
+            body=await async_maybe_transform(body, Iterable[subject_upsert_params.Body]),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SubjectUpsertResponse,
+        )
+
+
+class SubjectsResourceWithRawResponse:
+    def __init__(self, subjects: SubjectsResource) -> None:
+        self._subjects = subjects
+
+        self.retrieve = to_raw_response_wrapper(
+            subjects.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            subjects.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            subjects.delete,
+        )
+        self.upsert = to_raw_response_wrapper(
+            subjects.upsert,
+        )
+
+    @cached_property
+    def entitlements(self) -> EntitlementsResourceWithRawResponse:
+        return EntitlementsResourceWithRawResponse(self._subjects.entitlements)
+
+
+class AsyncSubjectsResourceWithRawResponse:
+    def __init__(self, subjects: AsyncSubjectsResource) -> None:
+        self._subjects = subjects
+
+        self.retrieve = async_to_raw_response_wrapper(
+            subjects.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            subjects.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            subjects.delete,
+        )
+        self.upsert = async_to_raw_response_wrapper(
+            subjects.upsert,
+        )
+
+    @cached_property
+    def entitlements(self) -> AsyncEntitlementsResourceWithRawResponse:
+        return AsyncEntitlementsResourceWithRawResponse(self._subjects.entitlements)
+
+
+class SubjectsResourceWithStreamingResponse:
+    def __init__(self, subjects: SubjectsResource) -> None:
+        self._subjects = subjects
+
+        self.retrieve = to_streamed_response_wrapper(
+            subjects.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            subjects.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            subjects.delete,
+        )
+        self.upsert = to_streamed_response_wrapper(
+            subjects.upsert,
+        )
+
+    @cached_property
+    def entitlements(self) -> EntitlementsResourceWithStreamingResponse:
+        return EntitlementsResourceWithStreamingResponse(self._subjects.entitlements)
+
+
+class AsyncSubjectsResourceWithStreamingResponse:
+    def __init__(self, subjects: AsyncSubjectsResource) -> None:
+        self._subjects = subjects
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            subjects.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            subjects.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            subjects.delete,
+        )
+        self.upsert = async_to_streamed_response_wrapper(
+            subjects.upsert,
+        )
+
+    @cached_property
+    def entitlements(self) -> AsyncEntitlementsResourceWithStreamingResponse:
+        return AsyncEntitlementsResourceWithStreamingResponse(self._subjects.entitlements)

openmeter/types/__init__.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .meter import Meter as Meter
+from .subject import Subject as Subject
+from .entitlement import Entitlement as Entitlement
+from .ingested_event import IngestedEvent as IngestedEvent
+from .event_list_params import EventListParams as EventListParams
+from .meter_query_params import MeterQueryParams as MeterQueryParams
+from .meter_query_result import MeterQueryResult as MeterQueryResult
+from .event_ingest_params import EventIngestParams as EventIngestParams
+from .event_list_response import EventListResponse as EventListResponse
+from .meter_create_params import MeterCreateParams as MeterCreateParams
+from .meter_list_response import MeterListResponse as MeterListResponse
+from .event_ingest_response import EventIngestResponse as EventIngestResponse
+from .subject_list_response import SubjectListResponse as SubjectListResponse
+from .subject_upsert_params import SubjectUpsertParams as SubjectUpsertParams
+from .entitlement_list_params import EntitlementListParams as EntitlementListParams
+from .subject_upsert_response import SubjectUpsertResponse as SubjectUpsertResponse
+from .list_entitlements_result import ListEntitlementsResult as ListEntitlementsResult

openmeter/types/debug/__init__.py

@@ -0,0 +1,5 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .metric_list_response import MetricListResponse as MetricListResponse

openmeter/types/debug/metric_list_response.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import TypeAlias
+
+__all__ = ["MetricListResponse"]
+
+MetricListResponse: TypeAlias = str

openmeter/types/entitlement.py

@@ -0,0 +1,238 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._utils import PropertyInfo
+from .._models import BaseModel
+
+__all__ = [
+    "Entitlement",
+    "EntitlementMetered",
+    "EntitlementMeteredCurrentUsagePeriod",
+    "EntitlementMeteredUsagePeriod",
+    "EntitlementStatic",
+    "EntitlementStaticCurrentUsagePeriod",
+    "EntitlementStaticUsagePeriod",
+    "EntitlementBaseTemplate",
+    "EntitlementBaseTemplateCurrentUsagePeriod",
+    "EntitlementBaseTemplateUsagePeriod",
+]
+
+
+class EntitlementMeteredCurrentUsagePeriod(BaseModel):
+    from_: datetime = FieldInfo(alias="from")
+    """Period start time."""
+
+    to: datetime
+    """Period end time."""
+
+
+class EntitlementMeteredUsagePeriod(BaseModel):
+    anchor: datetime
+    """A date-time anchor to base the recurring period on."""
+
+    interval: Literal["DAY", "WEEK", "MONTH", "YEAR"]
+    """The unit of time for the interval. One of: `day`, `week`, `month`, or `year`."""
+
+
+class EntitlementMetered(BaseModel):
+    id: str
+    """Readonly unique ULID identifier."""
+
+    created_at: datetime = FieldInfo(alias="createdAt")
+    """Timestamp of when the resource was created."""
+
+    current_usage_period: EntitlementMeteredCurrentUsagePeriod = FieldInfo(alias="currentUsagePeriod")
+    """A period with a start and end time."""
+
+    feature_id: str = FieldInfo(alias="featureId")
+    """The feature the subject is entitled to use."""
+
+    feature_key: str = FieldInfo(alias="featureKey")
+    """The feature the subject is entitled to use."""
+
+    last_reset: datetime = FieldInfo(alias="lastReset")
+    """The time the last reset happened."""
+
+    measure_usage_from: datetime = FieldInfo(alias="measureUsageFrom")
+    """The time from which usage is measured.
+
+    If not specified on creation, defaults to entitlement creation time.
+    """
+
+    subject_key: str = FieldInfo(alias="subjectKey")
+    """The identifier key unique to the subject"""
+
+    type: Literal["metered"]
+
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Timestamp of when the resource was last updated."""
+
+    usage_period: EntitlementMeteredUsagePeriod = FieldInfo(alias="usagePeriod")
+    """Recurring period with an interval and an anchor."""
+
+    deleted_at: Optional[datetime] = FieldInfo(alias="deletedAt", default=None)
+    """Timestamp of when the resource was permanently deleted."""
+
+    is_soft_limit: Optional[bool] = FieldInfo(alias="isSoftLimit", default=None)
+    """
+    If softLimit=true the subject can use the feature even if the entitlement is
+    exhausted, hasAccess will always be true.
+    """
+
+    issue_after_reset: Optional[float] = FieldInfo(alias="issueAfterReset", default=None)
+    """
+    You can grant usage automatically alongside the entitlement, the example
+    scenario would be creating a starting balance. If an amount is specified here, a
+    grant will be created alongside the entitlement with the specified amount. That
+    grant will have it's rollover settings configured in a way that after each reset
+    operation, the balance will return the original amount specified here. Manually
+    creating such a grant would mean having the "amount", "minRolloverAmount", and
+    "maxRolloverAmount" fields all be the same.
+    """
+
+    issue_after_reset_priority: Optional[int] = FieldInfo(alias="issueAfterResetPriority", default=None)
+    """Defines the grant priority for the default grant."""
+
+    is_unlimited: Optional[bool] = FieldInfo(alias="isUnlimited", default=None)
+    """Deprecated, ignored by the backend.
+
+    Please use isSoftLimit instead; this field will be removed in the future.
+    """
+
+    metadata: Optional[Dict[str, str]] = None
+    """
+    Set of key-value pairs. Metadata can be used to store additional information
+    about a resource.
+    """
+
+    preserve_overage_at_reset: Optional[bool] = FieldInfo(alias="preserveOverageAtReset", default=None)
+    """If true, the overage is preserved at reset. If false, the usage is reset to 0."""
+
+
+class EntitlementStaticCurrentUsagePeriod(BaseModel):
+    from_: datetime = FieldInfo(alias="from")
+    """Period start time."""
+
+    to: datetime
+    """Period end time."""
+
+
+class EntitlementStaticUsagePeriod(BaseModel):
+    anchor: datetime
+    """A date-time anchor to base the recurring period on."""
+
+    interval: Literal["DAY", "WEEK", "MONTH", "YEAR"]
+    """The unit of time for the interval. One of: `day`, `week`, `month`, or `year`."""
+
+
+class EntitlementStatic(BaseModel):
+    id: str
+    """Readonly unique ULID identifier."""
+
+    config: str
+    """The JSON parsable config of the entitlement.
+
+    This value is also returned when checking entitlement access and it is useful
+    for configuring fine-grained access settings to the feature, implemented in your
+    own system. Has to be an object.
+    """
+
+    created_at: datetime = FieldInfo(alias="createdAt")
+    """Timestamp of when the resource was created."""
+
+    feature_id: str = FieldInfo(alias="featureId")
+    """The feature the subject is entitled to use."""
+
+    feature_key: str = FieldInfo(alias="featureKey")
+    """The feature the subject is entitled to use."""
+
+    subject_key: str = FieldInfo(alias="subjectKey")
+    """The identifier key unique to the subject"""
+
+    type: Literal["static"]
+
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Timestamp of when the resource was last updated."""
+
+    current_usage_period: Optional[EntitlementStaticCurrentUsagePeriod] = FieldInfo(
+        alias="currentUsagePeriod", default=None
+    )
+    """A period with a start and end time."""
+
+    deleted_at: Optional[datetime] = FieldInfo(alias="deletedAt", default=None)
+    """Timestamp of when the resource was permanently deleted."""
+
+    metadata: Optional[Dict[str, str]] = None
+    """
+    Set of key-value pairs. Metadata can be used to store additional information
+    about a resource.
+    """
+
+    usage_period: Optional[EntitlementStaticUsagePeriod] = FieldInfo(alias="usagePeriod", default=None)
+    """Recurring period with an interval and an anchor."""
+
+
+class EntitlementBaseTemplateCurrentUsagePeriod(BaseModel):
+    from_: datetime = FieldInfo(alias="from")
+    """Period start time."""
+
+    to: datetime
+    """Period end time."""
+
+
+class EntitlementBaseTemplateUsagePeriod(BaseModel):
+    anchor: datetime
+    """A date-time anchor to base the recurring period on."""
+
+    interval: Literal["DAY", "WEEK", "MONTH", "YEAR"]
+    """The unit of time for the interval. One of: `day`, `week`, `month`, or `year`."""
+
+
+class EntitlementBaseTemplate(BaseModel):
+    id: str
+    """Readonly unique ULID identifier."""
+
+    created_at: datetime = FieldInfo(alias="createdAt")
+    """Timestamp of when the resource was created."""
+
+    feature_id: str = FieldInfo(alias="featureId")
+    """The feature the subject is entitled to use."""
+
+    feature_key: str = FieldInfo(alias="featureKey")
+    """The feature the subject is entitled to use."""
+
+    subject_key: str = FieldInfo(alias="subjectKey")
+    """The identifier key unique to the subject"""
+
+    type: Literal["metered", "boolean", "static"]
+    """Type of the entitlement."""
+
+    updated_at: datetime = FieldInfo(alias="updatedAt")
+    """Timestamp of when the resource was last updated."""
+
+    current_usage_period: Optional[EntitlementBaseTemplateCurrentUsagePeriod] = FieldInfo(
+        alias="currentUsagePeriod", default=None
+    )
+    """A period with a start and end time."""
+
+    deleted_at: Optional[datetime] = FieldInfo(alias="deletedAt", default=None)
+    """Timestamp of when the resource was permanently deleted."""
+
+    metadata: Optional[Dict[str, str]] = None
+    """
+    Set of key-value pairs. Metadata can be used to store additional information
+    about a resource.
+    """
+
+    usage_period: Optional[EntitlementBaseTemplateUsagePeriod] = FieldInfo(alias="usagePeriod", default=None)
+    """Recurring period with an interval and an anchor."""
+
+
+Entitlement: TypeAlias = Annotated[
+    Union[EntitlementMetered, EntitlementStatic, EntitlementBaseTemplate], PropertyInfo(discriminator="type")
+]