# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

from __future__ import annotations

from typing_extensions import Literal

import httpx

from .holds import (
    HoldsResource,
    AsyncHoldsResource,
    HoldsResourceWithRawResponse,
    AsyncHoldsResourceWithRawResponse,
    HoldsResourceWithStreamingResponse,
    AsyncHoldsResourceWithStreamingResponse,
)
from ...._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
from ...._utils import maybe_transform, async_maybe_transform
from .locations import (
    LocationsResource,
    AsyncLocationsResource,
    LocationsResourceWithRawResponse,
    AsyncLocationsResourceWithRawResponse,
    LocationsResourceWithStreamingResponse,
    AsyncLocationsResourceWithStreamingResponse,
)
from .retailers import (
    RetailersResource,
    AsyncRetailersResource,
    RetailersResourceWithRawResponse,
    AsyncRetailersResourceWithRawResponse,
    RetailersResourceWithStreamingResponse,
    AsyncRetailersResourceWithStreamingResponse,
)
from ...._compat import cached_property
from .show_groups import (
    ShowGroupsResource,
    AsyncShowGroupsResource,
    ShowGroupsResourceWithRawResponse,
    AsyncShowGroupsResourceWithRawResponse,
    ShowGroupsResourceWithStreamingResponse,
    AsyncShowGroupsResourceWithStreamingResponse,
)
from .shows.shows import (
    ShowsResource,
    AsyncShowsResource,
    ShowsResourceWithRawResponse,
    AsyncShowsResourceWithRawResponse,
    ShowsResourceWithStreamingResponse,
    AsyncShowsResourceWithStreamingResponse,
)
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 ....types.api import CategoryType, v2_login_params, v2_access_tokens_params, v2_retrieve_categories_params
from .notifications import (
    NotificationsResource,
    AsyncNotificationsResource,
    NotificationsResourceWithRawResponse,
    AsyncNotificationsResourceWithRawResponse,
    NotificationsResourceWithStreamingResponse,
    AsyncNotificationsResourceWithStreamingResponse,
)
from .orders.orders import (
    OrdersResource,
    AsyncOrdersResource,
    OrdersResourceWithRawResponse,
    AsyncOrdersResourceWithRawResponse,
    OrdersResourceWithStreamingResponse,
    AsyncOrdersResourceWithStreamingResponse,
)
from ...._base_client import make_request_options
from .customers.customers import (
    CustomersResource,
    AsyncCustomersResource,
    CustomersResourceWithRawResponse,
    AsyncCustomersResourceWithRawResponse,
    CustomersResourceWithStreamingResponse,
    AsyncCustomersResourceWithStreamingResponse,
)
from .contentful.contentful import (
    ContentfulResource,
    AsyncContentfulResource,
    ContentfulResourceWithRawResponse,
    AsyncContentfulResourceWithRawResponse,
    ContentfulResourceWithStreamingResponse,
    AsyncContentfulResourceWithStreamingResponse,
)
from ....types.api.category_type import CategoryType
from ....types.api.v2_access_tokens_response import V2AccessTokensResponse
from ....types.api.v2_retrieve_categories_response import V2RetrieveCategoriesResponse
from ....types.api.v2_retrieve_app_versions_response import V2RetrieveAppVersionsResponse

__all__ = ["V2Resource", "AsyncV2Resource"]


class V2Resource(SyncAPIResource):
    @cached_property
    def customers(self) -> CustomersResource:
        return CustomersResource(self._client)

    @cached_property
    def contentful(self) -> ContentfulResource:
        return ContentfulResource(self._client)

    @cached_property
    def holds(self) -> HoldsResource:
        return HoldsResource(self._client)

    @cached_property
    def locations(self) -> LocationsResource:
        return LocationsResource(self._client)

    @cached_property
    def notifications(self) -> NotificationsResource:
        return NotificationsResource(self._client)

    @cached_property
    def orders(self) -> OrdersResource:
        return OrdersResource(self._client)

    @cached_property
    def retailers(self) -> RetailersResource:
        return RetailersResource(self._client)

    @cached_property
    def shows(self) -> ShowsResource:
        return ShowsResource(self._client)

    @cached_property
    def show_groups(self) -> ShowGroupsResource:
        return ShowGroupsResource(self._client)

    @cached_property
    def with_raw_response(self) -> V2ResourceWithRawResponse:
        """
        This property can be used as a prefix for any HTTP method call to return
        the raw response object instead of the parsed content.

        For more information, see https://www.github.com/alisytsma/ali-test-mcp#accessing-raw-response-data-eg-headers
        """
        return V2ResourceWithRawResponse(self)

    @cached_property
    def with_streaming_response(self) -> V2ResourceWithStreamingResponse:
        """
        An alternative to `.with_raw_response` that doesn't eagerly read the response body.

        For more information, see https://www.github.com/alisytsma/ali-test-mcp#with_streaming_response
        """
        return V2ResourceWithStreamingResponse(self)

    def access_tokens(
        self,
        *,
        code: str,
        grant_type: Literal["authorizationCode"],
        email: str | NotGiven = NOT_GIVEN,
        scope: Literal["customer"] | NotGiven = NOT_GIVEN,
        transfer_email: str | NotGiven = NOT_GIVEN,
        transfer_order_confirmation: str | NotGiven = NOT_GIVEN,
        # 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,
    ) -> V2AccessTokensResponse:
        """
        Returns a scoped access token based on the generated link token.

        Args:
          code: Code used to generate JWT. Should be a valid code stored and redis that holds
              the customer pub id as value.

          grant_type: Grant types allowed for authenticating.

          email: Email address of the customer

          scope: Scope to be used to created the JWT

          transfer_email: Email address of the customer transferring the order

          transfer_order_confirmation: Order confirmation number for the order that is going to be transferred to this
              customer

          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/v2/accessTokens",
            options=make_request_options(
                extra_headers=extra_headers,
                extra_query=extra_query,
                extra_body=extra_body,
                timeout=timeout,
                query=maybe_transform(
                    {
                        "code": code,
                        "grant_type": grant_type,
                        "email": email,
                        "scope": scope,
                        "transfer_email": transfer_email,
                        "transfer_order_confirmation": transfer_order_confirmation,
                    },
                    v2_access_tokens_params.V2AccessTokensParams,
                ),
            ),
            cast_to=V2AccessTokensResponse,
        )

    def login(
        self,
        *,
        email: str,
        source: str | NotGiven = NOT_GIVEN,
        # 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:
        """Generates a one-time password and sends it to the email address passed.

        In lower
        environments, the one-time password is returned in the response.

        Args:
          email: The email address to send the one-time password to.

          source: Optional source of the request. Use `CUSTOMER_SUPPORT_CHAT` if the request
              originates from the chat bot.

          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
        """
        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
        return self._post(
            "/api/v2/login",
            body=maybe_transform(
                {
                    "email": email,
                    "source": source,
                },
                v2_login_params.V2LoginParams,
            ),
            options=make_request_options(
                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
            ),
            cast_to=NoneType,
        )

    def retrieve_app_versions(
        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,
    ) -> V2RetrieveAppVersionsResponse:
        """Gets 'AppVersion' details.

        Includes version for iOS and Android. AccessToken is
        expected to be passed in headers.
        """
        return self._get(
            "/api/v2/appVersions",
            options=make_request_options(
                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
            ),
            cast_to=V2RetrieveAppVersionsResponse,
        )

    def retrieve_categories(
        self,
        *,
        name: str | NotGiven = NOT_GIVEN,
        type: CategoryType | NotGiven = NOT_GIVEN,
        # 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,
    ) -> V2RetrieveCategoriesResponse:
        """
        Get all Category resources.

        Args:
          name: Optionally filter by the category name.

          type: Optionally filter by the category type.

          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._get(
            "/api/v2/categories",
            options=make_request_options(
                extra_headers=extra_headers,
                extra_query=extra_query,
                extra_body=extra_body,
                timeout=timeout,
                query=maybe_transform(
                    {
                        "name": name,
                        "type": type,
                    },
                    v2_retrieve_categories_params.V2RetrieveCategoriesParams,
                ),
            ),
            cast_to=V2RetrieveCategoriesResponse,
        )


class AsyncV2Resource(AsyncAPIResource):
    @cached_property
    def customers(self) -> AsyncCustomersResource:
        return AsyncCustomersResource(self._client)

    @cached_property
    def contentful(self) -> AsyncContentfulResource:
        return AsyncContentfulResource(self._client)

    @cached_property
    def holds(self) -> AsyncHoldsResource:
        return AsyncHoldsResource(self._client)

    @cached_property
    def locations(self) -> AsyncLocationsResource:
        return AsyncLocationsResource(self._client)

    @cached_property
    def notifications(self) -> AsyncNotificationsResource:
        return AsyncNotificationsResource(self._client)

    @cached_property
    def orders(self) -> AsyncOrdersResource:
        return AsyncOrdersResource(self._client)

    @cached_property
    def retailers(self) -> AsyncRetailersResource:
        return AsyncRetailersResource(self._client)

    @cached_property
    def shows(self) -> AsyncShowsResource:
        return AsyncShowsResource(self._client)

    @cached_property
    def show_groups(self) -> AsyncShowGroupsResource:
        return AsyncShowGroupsResource(self._client)

    @cached_property
    def with_raw_response(self) -> AsyncV2ResourceWithRawResponse:
        """
        This property can be used as a prefix for any HTTP method call to return
        the raw response object instead of the parsed content.

        For more information, see https://www.github.com/alisytsma/ali-test-mcp#accessing-raw-response-data-eg-headers
        """
        return AsyncV2ResourceWithRawResponse(self)

    @cached_property
    def with_streaming_response(self) -> AsyncV2ResourceWithStreamingResponse:
        """
        An alternative to `.with_raw_response` that doesn't eagerly read the response body.

        For more information, see https://www.github.com/alisytsma/ali-test-mcp#with_streaming_response
        """
        return AsyncV2ResourceWithStreamingResponse(self)

    async def access_tokens(
        self,
        *,
        code: str,
        grant_type: Literal["authorizationCode"],
        email: str | NotGiven = NOT_GIVEN,
        scope: Literal["customer"] | NotGiven = NOT_GIVEN,
        transfer_email: str | NotGiven = NOT_GIVEN,
        transfer_order_confirmation: str | NotGiven = NOT_GIVEN,
        # 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,
    ) -> V2AccessTokensResponse:
        """
        Returns a scoped access token based on the generated link token.

        Args:
          code: Code used to generate JWT. Should be a valid code stored and redis that holds
              the customer pub id as value.

          grant_type: Grant types allowed for authenticating.

          email: Email address of the customer

          scope: Scope to be used to created the JWT

          transfer_email: Email address of the customer transferring the order

          transfer_order_confirmation: Order confirmation number for the order that is going to be transferred to this
              customer

          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/v2/accessTokens",
            options=make_request_options(
                extra_headers=extra_headers,
                extra_query=extra_query,
                extra_body=extra_body,
                timeout=timeout,
                query=await async_maybe_transform(
                    {
                        "code": code,
                        "grant_type": grant_type,
                        "email": email,
                        "scope": scope,
                        "transfer_email": transfer_email,
                        "transfer_order_confirmation": transfer_order_confirmation,
                    },
                    v2_access_tokens_params.V2AccessTokensParams,
                ),
            ),
            cast_to=V2AccessTokensResponse,
        )

    async def login(
        self,
        *,
        email: str,
        source: str | NotGiven = NOT_GIVEN,
        # 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:
        """Generates a one-time password and sends it to the email address passed.

        In lower
        environments, the one-time password is returned in the response.

        Args:
          email: The email address to send the one-time password to.

          source: Optional source of the request. Use `CUSTOMER_SUPPORT_CHAT` if the request
              originates from the chat bot.

          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
        """
        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
        return await self._post(
            "/api/v2/login",
            body=await async_maybe_transform(
                {
                    "email": email,
                    "source": source,
                },
                v2_login_params.V2LoginParams,
            ),
            options=make_request_options(
                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
            ),
            cast_to=NoneType,
        )

    async def retrieve_app_versions(
        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,
    ) -> V2RetrieveAppVersionsResponse:
        """Gets 'AppVersion' details.

        Includes version for iOS and Android. AccessToken is
        expected to be passed in headers.
        """
        return await self._get(
            "/api/v2/appVersions",
            options=make_request_options(
                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
            ),
            cast_to=V2RetrieveAppVersionsResponse,
        )

    async def retrieve_categories(
        self,
        *,
        name: str | NotGiven = NOT_GIVEN,
        type: CategoryType | NotGiven = NOT_GIVEN,
        # 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,
    ) -> V2RetrieveCategoriesResponse:
        """
        Get all Category resources.

        Args:
          name: Optionally filter by the category name.

          type: Optionally filter by the category type.

          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._get(
            "/api/v2/categories",
            options=make_request_options(
                extra_headers=extra_headers,
                extra_query=extra_query,
                extra_body=extra_body,
                timeout=timeout,
                query=await async_maybe_transform(
                    {
                        "name": name,
                        "type": type,
                    },
                    v2_retrieve_categories_params.V2RetrieveCategoriesParams,
                ),
            ),
            cast_to=V2RetrieveCategoriesResponse,
        )


class V2ResourceWithRawResponse:
    def __init__(self, v2: V2Resource) -> None:
        self._v2 = v2

        self.access_tokens = to_raw_response_wrapper(
            v2.access_tokens,
        )
        self.login = to_raw_response_wrapper(
            v2.login,
        )
        self.retrieve_app_versions = to_raw_response_wrapper(
            v2.retrieve_app_versions,
        )
        self.retrieve_categories = to_raw_response_wrapper(
            v2.retrieve_categories,
        )

    @cached_property
    def customers(self) -> CustomersResourceWithRawResponse:
        return CustomersResourceWithRawResponse(self._v2.customers)

    @cached_property
    def contentful(self) -> ContentfulResourceWithRawResponse:
        return ContentfulResourceWithRawResponse(self._v2.contentful)

    @cached_property
    def holds(self) -> HoldsResourceWithRawResponse:
        return HoldsResourceWithRawResponse(self._v2.holds)

    @cached_property
    def locations(self) -> LocationsResourceWithRawResponse:
        return LocationsResourceWithRawResponse(self._v2.locations)

    @cached_property
    def notifications(self) -> NotificationsResourceWithRawResponse:
        return NotificationsResourceWithRawResponse(self._v2.notifications)

    @cached_property
    def orders(self) -> OrdersResourceWithRawResponse:
        return OrdersResourceWithRawResponse(self._v2.orders)

    @cached_property
    def retailers(self) -> RetailersResourceWithRawResponse:
        return RetailersResourceWithRawResponse(self._v2.retailers)

    @cached_property
    def shows(self) -> ShowsResourceWithRawResponse:
        return ShowsResourceWithRawResponse(self._v2.shows)

    @cached_property
    def show_groups(self) -> ShowGroupsResourceWithRawResponse:
        return ShowGroupsResourceWithRawResponse(self._v2.show_groups)


class AsyncV2ResourceWithRawResponse:
    def __init__(self, v2: AsyncV2Resource) -> None:
        self._v2 = v2

        self.access_tokens = async_to_raw_response_wrapper(
            v2.access_tokens,
        )
        self.login = async_to_raw_response_wrapper(
            v2.login,
        )
        self.retrieve_app_versions = async_to_raw_response_wrapper(
            v2.retrieve_app_versions,
        )
        self.retrieve_categories = async_to_raw_response_wrapper(
            v2.retrieve_categories,
        )

    @cached_property
    def customers(self) -> AsyncCustomersResourceWithRawResponse:
        return AsyncCustomersResourceWithRawResponse(self._v2.customers)

    @cached_property
    def contentful(self) -> AsyncContentfulResourceWithRawResponse:
        return AsyncContentfulResourceWithRawResponse(self._v2.contentful)

    @cached_property
    def holds(self) -> AsyncHoldsResourceWithRawResponse:
        return AsyncHoldsResourceWithRawResponse(self._v2.holds)

    @cached_property
    def locations(self) -> AsyncLocationsResourceWithRawResponse:
        return AsyncLocationsResourceWithRawResponse(self._v2.locations)

    @cached_property
    def notifications(self) -> AsyncNotificationsResourceWithRawResponse:
        return AsyncNotificationsResourceWithRawResponse(self._v2.notifications)

    @cached_property
    def orders(self) -> AsyncOrdersResourceWithRawResponse:
        return AsyncOrdersResourceWithRawResponse(self._v2.orders)

    @cached_property
    def retailers(self) -> AsyncRetailersResourceWithRawResponse:
        return AsyncRetailersResourceWithRawResponse(self._v2.retailers)

    @cached_property
    def shows(self) -> AsyncShowsResourceWithRawResponse:
        return AsyncShowsResourceWithRawResponse(self._v2.shows)

    @cached_property
    def show_groups(self) -> AsyncShowGroupsResourceWithRawResponse:
        return AsyncShowGroupsResourceWithRawResponse(self._v2.show_groups)


class V2ResourceWithStreamingResponse:
    def __init__(self, v2: V2Resource) -> None:
        self._v2 = v2

        self.access_tokens = to_streamed_response_wrapper(
            v2.access_tokens,
        )
        self.login = to_streamed_response_wrapper(
            v2.login,
        )
        self.retrieve_app_versions = to_streamed_response_wrapper(
            v2.retrieve_app_versions,
        )
        self.retrieve_categories = to_streamed_response_wrapper(
            v2.retrieve_categories,
        )

    @cached_property
    def customers(self) -> CustomersResourceWithStreamingResponse:
        return CustomersResourceWithStreamingResponse(self._v2.customers)

    @cached_property
    def contentful(self) -> ContentfulResourceWithStreamingResponse:
        return ContentfulResourceWithStreamingResponse(self._v2.contentful)

    @cached_property
    def holds(self) -> HoldsResourceWithStreamingResponse:
        return HoldsResourceWithStreamingResponse(self._v2.holds)

    @cached_property
    def locations(self) -> LocationsResourceWithStreamingResponse:
        return LocationsResourceWithStreamingResponse(self._v2.locations)

    @cached_property
    def notifications(self) -> NotificationsResourceWithStreamingResponse:
        return NotificationsResourceWithStreamingResponse(self._v2.notifications)

    @cached_property
    def orders(self) -> OrdersResourceWithStreamingResponse:
        return OrdersResourceWithStreamingResponse(self._v2.orders)

    @cached_property
    def retailers(self) -> RetailersResourceWithStreamingResponse:
        return RetailersResourceWithStreamingResponse(self._v2.retailers)

    @cached_property
    def shows(self) -> ShowsResourceWithStreamingResponse:
        return ShowsResourceWithStreamingResponse(self._v2.shows)

    @cached_property
    def show_groups(self) -> ShowGroupsResourceWithStreamingResponse:
        return ShowGroupsResourceWithStreamingResponse(self._v2.show_groups)


class AsyncV2ResourceWithStreamingResponse:
    def __init__(self, v2: AsyncV2Resource) -> None:
        self._v2 = v2

        self.access_tokens = async_to_streamed_response_wrapper(
            v2.access_tokens,
        )
        self.login = async_to_streamed_response_wrapper(
            v2.login,
        )
        self.retrieve_app_versions = async_to_streamed_response_wrapper(
            v2.retrieve_app_versions,
        )
        self.retrieve_categories = async_to_streamed_response_wrapper(
            v2.retrieve_categories,
        )

    @cached_property
    def customers(self) -> AsyncCustomersResourceWithStreamingResponse:
        return AsyncCustomersResourceWithStreamingResponse(self._v2.customers)

    @cached_property
    def contentful(self) -> AsyncContentfulResourceWithStreamingResponse:
        return AsyncContentfulResourceWithStreamingResponse(self._v2.contentful)

    @cached_property
    def holds(self) -> AsyncHoldsResourceWithStreamingResponse:
        return AsyncHoldsResourceWithStreamingResponse(self._v2.holds)

    @cached_property
    def locations(self) -> AsyncLocationsResourceWithStreamingResponse:
        return AsyncLocationsResourceWithStreamingResponse(self._v2.locations)

    @cached_property
    def notifications(self) -> AsyncNotificationsResourceWithStreamingResponse:
        return AsyncNotificationsResourceWithStreamingResponse(self._v2.notifications)

    @cached_property
    def orders(self) -> AsyncOrdersResourceWithStreamingResponse:
        return AsyncOrdersResourceWithStreamingResponse(self._v2.orders)

    @cached_property
    def retailers(self) -> AsyncRetailersResourceWithStreamingResponse:
        return AsyncRetailersResourceWithStreamingResponse(self._v2.retailers)

    @cached_property
    def shows(self) -> AsyncShowsResourceWithStreamingResponse:
        return AsyncShowsResourceWithStreamingResponse(self._v2.shows)

    @cached_property
    def show_groups(self) -> AsyncShowGroupsResourceWithStreamingResponse:
        return AsyncShowGroupsResourceWithStreamingResponse(self._v2.show_groups)
