diff --git a/.stats.yml b/.stats.yml index 7b2ebfa9..87b67dee 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,2 +1,2 @@ -configured_endpoints: 106 +configured_endpoints: 111 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/gitpod%2Fgitpod-36f9d46890bf3667f5a6529bdb156fe1560834ad8187c4271aa0b0024de1adb5.yml diff --git a/api.md b/api.md index 40b1aeab..d7e5d8e8 100644 --- a/api.md +++ b/api.md @@ -259,6 +259,29 @@ Methods: - client.organizations.list_members(\*\*params) -> SyncMembersPage[OrganizationMember] - client.organizations.set_role(\*\*params) -> object +## DomainVerifications + +Types: + +```python +from gitpod.types.organizations import ( + DomainVerification, + DomainVerificationState, + DomainVerificationCreateResponse, + DomainVerificationRetrieveResponse, + DomainVerificationDeleteResponse, + DomainVerificationVerifyResponse, +) +``` + +Methods: + +- client.organizations.domain_verifications.create(\*\*params) -> DomainVerificationCreateResponse +- client.organizations.domain_verifications.retrieve(\*\*params) -> DomainVerificationRetrieveResponse +- client.organizations.domain_verifications.list(\*\*params) -> SyncDomainVerificationsPage[DomainVerification] +- client.organizations.domain_verifications.delete(\*\*params) -> object +- client.organizations.domain_verifications.verify(\*\*params) -> DomainVerificationVerifyResponse + ## Invites Types: diff --git a/src/gitpod/pagination.py b/src/gitpod/pagination.py index 393e2f83..a8e74f8f 100644 --- a/src/gitpod/pagination.py +++ b/src/gitpod/pagination.py @@ -9,6 +9,9 @@ from ._base_client import BasePage, PageInfo, BaseSyncPage, BaseAsyncPage __all__ = [ + "DomainVerificationsPagePagination", + "SyncDomainVerificationsPage", + "AsyncDomainVerificationsPage", "EditorsPagePagination", "SyncEditorsPage", "AsyncEditorsPage", @@ -71,6 +74,56 @@ _T = TypeVar("_T") +class DomainVerificationsPagePagination(BaseModel): + next_token: Optional[str] = FieldInfo(alias="nextToken", default=None) + + +class SyncDomainVerificationsPage(BaseSyncPage[_T], BasePage[_T], Generic[_T]): + domain_verifications: List[_T] = FieldInfo(alias="domainVerifications") + pagination: Optional[DomainVerificationsPagePagination] = None + + @override + def _get_page_items(self) -> List[_T]: + domain_verifications = self.domain_verifications + if not domain_verifications: + return [] + return domain_verifications + + @override + def next_page_info(self) -> Optional[PageInfo]: + next_token = None + if self.pagination is not None: + if self.pagination.next_token is not None: + next_token = self.pagination.next_token + if not next_token: + return None + + return PageInfo(params={"token": next_token}) + + +class AsyncDomainVerificationsPage(BaseAsyncPage[_T], BasePage[_T], Generic[_T]): + domain_verifications: List[_T] = FieldInfo(alias="domainVerifications") + pagination: Optional[DomainVerificationsPagePagination] = None + + @override + def _get_page_items(self) -> List[_T]: + domain_verifications = self.domain_verifications + if not domain_verifications: + return [] + return domain_verifications + + @override + def next_page_info(self) -> Optional[PageInfo]: + next_token = None + if self.pagination is not None: + if self.pagination.next_token is not None: + next_token = self.pagination.next_token + if not next_token: + return None + + return PageInfo(params={"token": next_token}) + + class EditorsPagePagination(BaseModel): next_token: Optional[str] = FieldInfo(alias="nextToken", default=None) diff --git a/src/gitpod/resources/organizations/__init__.py b/src/gitpod/resources/organizations/__init__.py index 164bee21..3b7cf4ed 100644 --- a/src/gitpod/resources/organizations/__init__.py +++ b/src/gitpod/resources/organizations/__init__.py @@ -24,8 +24,22 @@ SSOConfigurationsResourceWithStreamingResponse, AsyncSSOConfigurationsResourceWithStreamingResponse, ) +from .domain_verifications import ( + DomainVerificationsResource, + AsyncDomainVerificationsResource, + DomainVerificationsResourceWithRawResponse, + AsyncDomainVerificationsResourceWithRawResponse, + DomainVerificationsResourceWithStreamingResponse, + AsyncDomainVerificationsResourceWithStreamingResponse, +) __all__ = [ + "DomainVerificationsResource", + "AsyncDomainVerificationsResource", + "DomainVerificationsResourceWithRawResponse", + "AsyncDomainVerificationsResourceWithRawResponse", + "DomainVerificationsResourceWithStreamingResponse", + "AsyncDomainVerificationsResourceWithStreamingResponse", "InvitesResource", "AsyncInvitesResource", "InvitesResourceWithRawResponse", diff --git a/src/gitpod/resources/organizations/domain_verifications.py b/src/gitpod/resources/organizations/domain_verifications.py new file mode 100644 index 00000000..37612897 --- /dev/null +++ b/src/gitpod/resources/organizations/domain_verifications.py @@ -0,0 +1,554 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ..._types import NOT_GIVEN, Body, Query, Headers, 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 ...pagination import SyncDomainVerificationsPage, AsyncDomainVerificationsPage +from ..._base_client import AsyncPaginator, make_request_options +from ...types.organizations import ( + domain_verification_list_params, + domain_verification_create_params, + domain_verification_delete_params, + domain_verification_verify_params, + domain_verification_retrieve_params, +) +from ...types.organizations.domain_verification import DomainVerification +from ...types.organizations.domain_verification_create_response import DomainVerificationCreateResponse +from ...types.organizations.domain_verification_verify_response import DomainVerificationVerifyResponse +from ...types.organizations.domain_verification_retrieve_response import DomainVerificationRetrieveResponse + +__all__ = ["DomainVerificationsResource", "AsyncDomainVerificationsResource"] + + +class DomainVerificationsResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> DomainVerificationsResourceWithRawResponse: + """ + 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/gitpod-io/gitpod-sdk-python#accessing-raw-response-data-eg-headers + """ + return DomainVerificationsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> DomainVerificationsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/gitpod-io/gitpod-sdk-python#with_streaming_response + """ + return DomainVerificationsResourceWithStreamingResponse(self) + + def create( + self, + *, + domain: str | NotGiven = NOT_GIVEN, + organization_id: 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, + ) -> DomainVerificationCreateResponse: + """ + CreateDomainVerification creates a new domain verification request + + 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( + "/gitpod.v1.OrganizationService/CreateDomainVerification", + body=maybe_transform( + { + "domain": domain, + "organization_id": organization_id, + }, + domain_verification_create_params.DomainVerificationCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DomainVerificationCreateResponse, + ) + + def retrieve( + self, + *, + domain_verification_id: 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, + ) -> DomainVerificationRetrieveResponse: + """ + GetDomainVerification retrieves a domain verification request + + 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( + "/gitpod.v1.OrganizationService/GetDomainVerification", + body=maybe_transform( + {"domain_verification_id": domain_verification_id}, + domain_verification_retrieve_params.DomainVerificationRetrieveParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DomainVerificationRetrieveResponse, + ) + + def list( + self, + *, + token: str | NotGiven = NOT_GIVEN, + page_size: int | NotGiven = NOT_GIVEN, + organization_id: str | NotGiven = NOT_GIVEN, + pagination: domain_verification_list_params.Pagination | 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, + ) -> SyncDomainVerificationsPage[DomainVerification]: + """ + ListDomainVerifications lists all domain verifications for an organization + + 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._get_api_list( + "/gitpod.v1.OrganizationService/ListDomainVerifications", + page=SyncDomainVerificationsPage[DomainVerification], + body=maybe_transform( + { + "organization_id": organization_id, + "pagination": pagination, + }, + domain_verification_list_params.DomainVerificationListParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "token": token, + "page_size": page_size, + }, + domain_verification_list_params.DomainVerificationListParams, + ), + ), + model=DomainVerification, + method="post", + ) + + def delete( + self, + *, + domain_verification_id: 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, + ) -> object: + """ + DeleteDomainVerification deletes a domain verification request + + 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( + "/gitpod.v1.OrganizationService/DeleteDomainVerification", + body=maybe_transform( + {"domain_verification_id": domain_verification_id}, + domain_verification_delete_params.DomainVerificationDeleteParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + + def verify( + self, + *, + domain_verification_id: 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, + ) -> DomainVerificationVerifyResponse: + """ + VerifyDomain verifies a domain ownership + + 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( + "/gitpod.v1.OrganizationService/VerifyDomain", + body=maybe_transform( + {"domain_verification_id": domain_verification_id}, + domain_verification_verify_params.DomainVerificationVerifyParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DomainVerificationVerifyResponse, + ) + + +class AsyncDomainVerificationsResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncDomainVerificationsResourceWithRawResponse: + """ + 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/gitpod-io/gitpod-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncDomainVerificationsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncDomainVerificationsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/gitpod-io/gitpod-sdk-python#with_streaming_response + """ + return AsyncDomainVerificationsResourceWithStreamingResponse(self) + + async def create( + self, + *, + domain: str | NotGiven = NOT_GIVEN, + organization_id: 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, + ) -> DomainVerificationCreateResponse: + """ + CreateDomainVerification creates a new domain verification request + + 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( + "/gitpod.v1.OrganizationService/CreateDomainVerification", + body=await async_maybe_transform( + { + "domain": domain, + "organization_id": organization_id, + }, + domain_verification_create_params.DomainVerificationCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DomainVerificationCreateResponse, + ) + + async def retrieve( + self, + *, + domain_verification_id: 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, + ) -> DomainVerificationRetrieveResponse: + """ + GetDomainVerification retrieves a domain verification request + + 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( + "/gitpod.v1.OrganizationService/GetDomainVerification", + body=await async_maybe_transform( + {"domain_verification_id": domain_verification_id}, + domain_verification_retrieve_params.DomainVerificationRetrieveParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DomainVerificationRetrieveResponse, + ) + + def list( + self, + *, + token: str | NotGiven = NOT_GIVEN, + page_size: int | NotGiven = NOT_GIVEN, + organization_id: str | NotGiven = NOT_GIVEN, + pagination: domain_verification_list_params.Pagination | 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, + ) -> AsyncPaginator[DomainVerification, AsyncDomainVerificationsPage[DomainVerification]]: + """ + ListDomainVerifications lists all domain verifications for an organization + + 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._get_api_list( + "/gitpod.v1.OrganizationService/ListDomainVerifications", + page=AsyncDomainVerificationsPage[DomainVerification], + body=maybe_transform( + { + "organization_id": organization_id, + "pagination": pagination, + }, + domain_verification_list_params.DomainVerificationListParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "token": token, + "page_size": page_size, + }, + domain_verification_list_params.DomainVerificationListParams, + ), + ), + model=DomainVerification, + method="post", + ) + + async def delete( + self, + *, + domain_verification_id: 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, + ) -> object: + """ + DeleteDomainVerification deletes a domain verification request + + 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( + "/gitpod.v1.OrganizationService/DeleteDomainVerification", + body=await async_maybe_transform( + {"domain_verification_id": domain_verification_id}, + domain_verification_delete_params.DomainVerificationDeleteParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=object, + ) + + async def verify( + self, + *, + domain_verification_id: 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, + ) -> DomainVerificationVerifyResponse: + """ + VerifyDomain verifies a domain ownership + + 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( + "/gitpod.v1.OrganizationService/VerifyDomain", + body=await async_maybe_transform( + {"domain_verification_id": domain_verification_id}, + domain_verification_verify_params.DomainVerificationVerifyParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=DomainVerificationVerifyResponse, + ) + + +class DomainVerificationsResourceWithRawResponse: + def __init__(self, domain_verifications: DomainVerificationsResource) -> None: + self._domain_verifications = domain_verifications + + self.create = to_raw_response_wrapper( + domain_verifications.create, + ) + self.retrieve = to_raw_response_wrapper( + domain_verifications.retrieve, + ) + self.list = to_raw_response_wrapper( + domain_verifications.list, + ) + self.delete = to_raw_response_wrapper( + domain_verifications.delete, + ) + self.verify = to_raw_response_wrapper( + domain_verifications.verify, + ) + + +class AsyncDomainVerificationsResourceWithRawResponse: + def __init__(self, domain_verifications: AsyncDomainVerificationsResource) -> None: + self._domain_verifications = domain_verifications + + self.create = async_to_raw_response_wrapper( + domain_verifications.create, + ) + self.retrieve = async_to_raw_response_wrapper( + domain_verifications.retrieve, + ) + self.list = async_to_raw_response_wrapper( + domain_verifications.list, + ) + self.delete = async_to_raw_response_wrapper( + domain_verifications.delete, + ) + self.verify = async_to_raw_response_wrapper( + domain_verifications.verify, + ) + + +class DomainVerificationsResourceWithStreamingResponse: + def __init__(self, domain_verifications: DomainVerificationsResource) -> None: + self._domain_verifications = domain_verifications + + self.create = to_streamed_response_wrapper( + domain_verifications.create, + ) + self.retrieve = to_streamed_response_wrapper( + domain_verifications.retrieve, + ) + self.list = to_streamed_response_wrapper( + domain_verifications.list, + ) + self.delete = to_streamed_response_wrapper( + domain_verifications.delete, + ) + self.verify = to_streamed_response_wrapper( + domain_verifications.verify, + ) + + +class AsyncDomainVerificationsResourceWithStreamingResponse: + def __init__(self, domain_verifications: AsyncDomainVerificationsResource) -> None: + self._domain_verifications = domain_verifications + + self.create = async_to_streamed_response_wrapper( + domain_verifications.create, + ) + self.retrieve = async_to_streamed_response_wrapper( + domain_verifications.retrieve, + ) + self.list = async_to_streamed_response_wrapper( + domain_verifications.list, + ) + self.delete = async_to_streamed_response_wrapper( + domain_verifications.delete, + ) + self.verify = async_to_streamed_response_wrapper( + domain_verifications.verify, + ) diff --git a/src/gitpod/resources/organizations/organizations.py b/src/gitpod/resources/organizations/organizations.py index d10cb521..8707b720 100644 --- a/src/gitpod/resources/organizations/organizations.py +++ b/src/gitpod/resources/organizations/organizations.py @@ -51,6 +51,14 @@ AsyncSSOConfigurationsResourceWithStreamingResponse, ) from ...types.organization import Organization +from .domain_verifications import ( + DomainVerificationsResource, + AsyncDomainVerificationsResource, + DomainVerificationsResourceWithRawResponse, + AsyncDomainVerificationsResourceWithRawResponse, + DomainVerificationsResourceWithStreamingResponse, + AsyncDomainVerificationsResourceWithStreamingResponse, +) from ...types.organization_member import OrganizationMember from ...types.invite_domains_param import InviteDomainsParam from ...types.shared.organization_role import OrganizationRole @@ -63,6 +71,10 @@ class OrganizationsResource(SyncAPIResource): + @cached_property + def domain_verifications(self) -> DomainVerificationsResource: + return DomainVerificationsResource(self._client) + @cached_property def invites(self) -> InvitesResource: return InvitesResource(self._client) @@ -490,6 +502,10 @@ def set_role( class AsyncOrganizationsResource(AsyncAPIResource): + @cached_property + def domain_verifications(self) -> AsyncDomainVerificationsResource: + return AsyncDomainVerificationsResource(self._client) + @cached_property def invites(self) -> AsyncInvitesResource: return AsyncInvitesResource(self._client) @@ -948,6 +964,10 @@ def __init__(self, organizations: OrganizationsResource) -> None: organizations.set_role, ) + @cached_property + def domain_verifications(self) -> DomainVerificationsResourceWithRawResponse: + return DomainVerificationsResourceWithRawResponse(self._organizations.domain_verifications) + @cached_property def invites(self) -> InvitesResourceWithRawResponse: return InvitesResourceWithRawResponse(self._organizations.invites) @@ -989,6 +1009,10 @@ def __init__(self, organizations: AsyncOrganizationsResource) -> None: organizations.set_role, ) + @cached_property + def domain_verifications(self) -> AsyncDomainVerificationsResourceWithRawResponse: + return AsyncDomainVerificationsResourceWithRawResponse(self._organizations.domain_verifications) + @cached_property def invites(self) -> AsyncInvitesResourceWithRawResponse: return AsyncInvitesResourceWithRawResponse(self._organizations.invites) @@ -1030,6 +1054,10 @@ def __init__(self, organizations: OrganizationsResource) -> None: organizations.set_role, ) + @cached_property + def domain_verifications(self) -> DomainVerificationsResourceWithStreamingResponse: + return DomainVerificationsResourceWithStreamingResponse(self._organizations.domain_verifications) + @cached_property def invites(self) -> InvitesResourceWithStreamingResponse: return InvitesResourceWithStreamingResponse(self._organizations.invites) @@ -1071,6 +1099,10 @@ def __init__(self, organizations: AsyncOrganizationsResource) -> None: organizations.set_role, ) + @cached_property + def domain_verifications(self) -> AsyncDomainVerificationsResourceWithStreamingResponse: + return AsyncDomainVerificationsResourceWithStreamingResponse(self._organizations.domain_verifications) + @cached_property def invites(self) -> AsyncInvitesResourceWithStreamingResponse: return AsyncInvitesResourceWithStreamingResponse(self._organizations.invites) diff --git a/src/gitpod/types/organizations/__init__.py b/src/gitpod/types/organizations/__init__.py index ce9a3996..83301d79 100644 --- a/src/gitpod/types/organizations/__init__.py +++ b/src/gitpod/types/organizations/__init__.py @@ -4,18 +4,30 @@ from .provider_type import ProviderType as ProviderType from .sso_configuration import SSOConfiguration as SSOConfiguration +from .domain_verification import DomainVerification as DomainVerification from .organization_invite import OrganizationInvite as OrganizationInvite from .invite_create_params import InviteCreateParams as InviteCreateParams from .invite_create_response import InviteCreateResponse as InviteCreateResponse from .invite_retrieve_params import InviteRetrieveParams as InviteRetrieveParams from .sso_configuration_state import SSOConfigurationState as SSOConfigurationState from .invite_retrieve_response import InviteRetrieveResponse as InviteRetrieveResponse +from .domain_verification_state import DomainVerificationState as DomainVerificationState from .invite_get_summary_params import InviteGetSummaryParams as InviteGetSummaryParams from .invite_get_summary_response import InviteGetSummaryResponse as InviteGetSummaryResponse from .sso_configuration_list_params import SSOConfigurationListParams as SSOConfigurationListParams +from .domain_verification_list_params import DomainVerificationListParams as DomainVerificationListParams from .sso_configuration_create_params import SSOConfigurationCreateParams as SSOConfigurationCreateParams from .sso_configuration_delete_params import SSOConfigurationDeleteParams as SSOConfigurationDeleteParams from .sso_configuration_update_params import SSOConfigurationUpdateParams as SSOConfigurationUpdateParams +from .domain_verification_create_params import DomainVerificationCreateParams as DomainVerificationCreateParams +from .domain_verification_delete_params import DomainVerificationDeleteParams as DomainVerificationDeleteParams +from .domain_verification_verify_params import DomainVerificationVerifyParams as DomainVerificationVerifyParams from .sso_configuration_create_response import SSOConfigurationCreateResponse as SSOConfigurationCreateResponse from .sso_configuration_retrieve_params import SSOConfigurationRetrieveParams as SSOConfigurationRetrieveParams +from .domain_verification_create_response import DomainVerificationCreateResponse as DomainVerificationCreateResponse +from .domain_verification_retrieve_params import DomainVerificationRetrieveParams as DomainVerificationRetrieveParams +from .domain_verification_verify_response import DomainVerificationVerifyResponse as DomainVerificationVerifyResponse from .sso_configuration_retrieve_response import SSOConfigurationRetrieveResponse as SSOConfigurationRetrieveResponse +from .domain_verification_retrieve_response import ( + DomainVerificationRetrieveResponse as DomainVerificationRetrieveResponse, +) diff --git a/src/gitpod/types/organizations/domain_verification.py b/src/gitpod/types/organizations/domain_verification.py new file mode 100644 index 00000000..04d9847a --- /dev/null +++ b/src/gitpod/types/organizations/domain_verification.py @@ -0,0 +1,113 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional +from datetime import datetime + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel +from .domain_verification_state import DomainVerificationState + +__all__ = ["DomainVerification"] + + +class DomainVerification(BaseModel): + id: Optional[str] = None + + domain: Optional[str] = None + + organization_id: Optional[str] = FieldInfo(alias="organizationId", default=None) + + state: Optional[DomainVerificationState] = None + + verified_at: Optional[datetime] = FieldInfo(alias="verifiedAt", default=None) + """ + A Timestamp represents a point in time independent of any time zone or local + calendar, encoded as a count of seconds and fractions of seconds at nanosecond + resolution. The count is relative to an epoch at UTC midnight on January 1, + 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar + backwards to year one. + + All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap + second table is needed for interpretation, using a + [24-hour linear smear](https://developers.google.com/time/smear). + + The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By + restricting to that range, we ensure that we can convert to and from + [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. + + # Examples + + Example 1: Compute Timestamp from POSIX `time()`. + + Timestamp timestamp; + timestamp.set_seconds(time(NULL)); + timestamp.set_nanos(0); + + Example 2: Compute Timestamp from POSIX `gettimeofday()`. + + struct timeval tv; + gettimeofday(&tv, NULL); + + Timestamp timestamp; + timestamp.set_seconds(tv.tv_sec); + timestamp.set_nanos(tv.tv_usec * 1000); + + Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. + + FILETIME ft; + GetSystemTimeAsFileTime(&ft); + UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; + + // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z + // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. + Timestamp timestamp; + timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); + timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); + + Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. + + long millis = System.currentTimeMillis(); + + Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) + .setNanos((int) ((millis % 1000) * 1000000)).build(); + + Example 5: Compute Timestamp from Java `Instant.now()`. + + Instant now = Instant.now(); + + Timestamp timestamp = + Timestamp.newBuilder().setSeconds(now.getEpochSecond()) + .setNanos(now.getNano()).build(); + + Example 6: Compute Timestamp from current time in Python. + + timestamp = Timestamp() + timestamp.GetCurrentTime() + + # JSON Mapping + + In JSON format, the Timestamp type is encoded as a string in the + [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is + "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always + expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are + zero-padded to two digits each. The fractional seconds, which can go up to 9 + digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix + indicates the timezone ("UTC"); the timezone is required. A proto3 JSON + serializer should always use UTC (as indicated by "Z") when printing the + Timestamp type and a proto3 JSON parser should be able to accept both UTC and + other timezones (as indicated by an offset). + + For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on + January 15, 2017. + + In JavaScript, one can convert a Date object to this format using the standard + [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) + method. In Python, a standard `datetime.datetime` object can be converted to + this format using + [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the + time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the + Joda Time's + [`ISODateTimeFormat.dateTime()`]() + to obtain a formatter capable of generating timestamps in this format. + """ diff --git a/src/gitpod/types/organizations/domain_verification_create_params.py b/src/gitpod/types/organizations/domain_verification_create_params.py new file mode 100644 index 00000000..317c1589 --- /dev/null +++ b/src/gitpod/types/organizations/domain_verification_create_params.py @@ -0,0 +1,15 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["DomainVerificationCreateParams"] + + +class DomainVerificationCreateParams(TypedDict, total=False): + domain: str + + organization_id: Annotated[str, PropertyInfo(alias="organizationId")] diff --git a/src/gitpod/types/organizations/domain_verification_create_response.py b/src/gitpod/types/organizations/domain_verification_create_response.py new file mode 100644 index 00000000..c42eb645 --- /dev/null +++ b/src/gitpod/types/organizations/domain_verification_create_response.py @@ -0,0 +1,14 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel +from .domain_verification import DomainVerification + +__all__ = ["DomainVerificationCreateResponse"] + + +class DomainVerificationCreateResponse(BaseModel): + domain_verification: Optional[DomainVerification] = FieldInfo(alias="domainVerification", default=None) diff --git a/src/gitpod/types/organizations/domain_verification_delete_params.py b/src/gitpod/types/organizations/domain_verification_delete_params.py new file mode 100644 index 00000000..15025b93 --- /dev/null +++ b/src/gitpod/types/organizations/domain_verification_delete_params.py @@ -0,0 +1,13 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["DomainVerificationDeleteParams"] + + +class DomainVerificationDeleteParams(TypedDict, total=False): + domain_verification_id: Annotated[str, PropertyInfo(alias="domainVerificationId")] diff --git a/src/gitpod/types/organizations/domain_verification_list_params.py b/src/gitpod/types/organizations/domain_verification_list_params.py new file mode 100644 index 00000000..dfa94c2a --- /dev/null +++ b/src/gitpod/types/organizations/domain_verification_list_params.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["DomainVerificationListParams", "Pagination"] + + +class DomainVerificationListParams(TypedDict, total=False): + token: str + + page_size: Annotated[int, PropertyInfo(alias="pageSize")] + + organization_id: Annotated[str, PropertyInfo(alias="organizationId")] + + pagination: Pagination + + +class Pagination(TypedDict, total=False): + token: str + """ + Token for the next set of results that was returned as next_token of a + PaginationResponse + """ + + page_size: Annotated[int, PropertyInfo(alias="pageSize")] + """Page size is the maximum number of results to retrieve per page. Defaults to 25. + + Maximum 100. + """ diff --git a/src/gitpod/types/organizations/domain_verification_retrieve_params.py b/src/gitpod/types/organizations/domain_verification_retrieve_params.py new file mode 100644 index 00000000..c4717202 --- /dev/null +++ b/src/gitpod/types/organizations/domain_verification_retrieve_params.py @@ -0,0 +1,13 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["DomainVerificationRetrieveParams"] + + +class DomainVerificationRetrieveParams(TypedDict, total=False): + domain_verification_id: Annotated[str, PropertyInfo(alias="domainVerificationId")] diff --git a/src/gitpod/types/organizations/domain_verification_retrieve_response.py b/src/gitpod/types/organizations/domain_verification_retrieve_response.py new file mode 100644 index 00000000..06d27377 --- /dev/null +++ b/src/gitpod/types/organizations/domain_verification_retrieve_response.py @@ -0,0 +1,14 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel +from .domain_verification import DomainVerification + +__all__ = ["DomainVerificationRetrieveResponse"] + + +class DomainVerificationRetrieveResponse(BaseModel): + domain_verification: Optional[DomainVerification] = FieldInfo(alias="domainVerification", default=None) diff --git a/src/gitpod/types/organizations/domain_verification_state.py b/src/gitpod/types/organizations/domain_verification_state.py new file mode 100644 index 00000000..cc7a6d89 --- /dev/null +++ b/src/gitpod/types/organizations/domain_verification_state.py @@ -0,0 +1,9 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import Literal, TypeAlias + +__all__ = ["DomainVerificationState"] + +DomainVerificationState: TypeAlias = Literal[ + "DOMAIN_VERIFICATION_STATE_UNSPECIFIED", "DOMAIN_VERIFICATION_STATE_PENDING", "DOMAIN_VERIFICATION_STATE_VERIFIED" +] diff --git a/src/gitpod/types/organizations/domain_verification_verify_params.py b/src/gitpod/types/organizations/domain_verification_verify_params.py new file mode 100644 index 00000000..7f96c204 --- /dev/null +++ b/src/gitpod/types/organizations/domain_verification_verify_params.py @@ -0,0 +1,13 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["DomainVerificationVerifyParams"] + + +class DomainVerificationVerifyParams(TypedDict, total=False): + domain_verification_id: Annotated[str, PropertyInfo(alias="domainVerificationId")] diff --git a/src/gitpod/types/organizations/domain_verification_verify_response.py b/src/gitpod/types/organizations/domain_verification_verify_response.py new file mode 100644 index 00000000..91c00533 --- /dev/null +++ b/src/gitpod/types/organizations/domain_verification_verify_response.py @@ -0,0 +1,14 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel +from .domain_verification import DomainVerification + +__all__ = ["DomainVerificationVerifyResponse"] + + +class DomainVerificationVerifyResponse(BaseModel): + domain_verification: Optional[DomainVerification] = FieldInfo(alias="domainVerification", default=None) diff --git a/tests/api_resources/organizations/test_domain_verifications.py b/tests/api_resources/organizations/test_domain_verifications.py new file mode 100644 index 00000000..9a170cf5 --- /dev/null +++ b/tests/api_resources/organizations/test_domain_verifications.py @@ -0,0 +1,404 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from gitpod import Gitpod, AsyncGitpod +from tests.utils import assert_matches_type +from gitpod.pagination import SyncDomainVerificationsPage, AsyncDomainVerificationsPage +from gitpod.types.organizations import ( + DomainVerification, + DomainVerificationCreateResponse, + DomainVerificationVerifyResponse, + DomainVerificationRetrieveResponse, +) + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestDomainVerifications: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + def test_method_create(self, client: Gitpod) -> None: + domain_verification = client.organizations.domain_verifications.create() + assert_matches_type(DomainVerificationCreateResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_create_with_all_params(self, client: Gitpod) -> None: + domain_verification = client.organizations.domain_verifications.create( + domain="xxxx", + organization_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(DomainVerificationCreateResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_create(self, client: Gitpod) -> None: + response = client.organizations.domain_verifications.with_raw_response.create() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain_verification = response.parse() + assert_matches_type(DomainVerificationCreateResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_create(self, client: Gitpod) -> None: + with client.organizations.domain_verifications.with_streaming_response.create() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain_verification = response.parse() + assert_matches_type(DomainVerificationCreateResponse, domain_verification, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_method_retrieve(self, client: Gitpod) -> None: + domain_verification = client.organizations.domain_verifications.retrieve() + assert_matches_type(DomainVerificationRetrieveResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_retrieve_with_all_params(self, client: Gitpod) -> None: + domain_verification = client.organizations.domain_verifications.retrieve( + domain_verification_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(DomainVerificationRetrieveResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_retrieve(self, client: Gitpod) -> None: + response = client.organizations.domain_verifications.with_raw_response.retrieve() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain_verification = response.parse() + assert_matches_type(DomainVerificationRetrieveResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_retrieve(self, client: Gitpod) -> None: + with client.organizations.domain_verifications.with_streaming_response.retrieve() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain_verification = response.parse() + assert_matches_type(DomainVerificationRetrieveResponse, domain_verification, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_method_list(self, client: Gitpod) -> None: + domain_verification = client.organizations.domain_verifications.list() + assert_matches_type(SyncDomainVerificationsPage[DomainVerification], domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_list_with_all_params(self, client: Gitpod) -> None: + domain_verification = client.organizations.domain_verifications.list( + token="token", + page_size=0, + organization_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + pagination={ + "token": "token", + "page_size": 100, + }, + ) + assert_matches_type(SyncDomainVerificationsPage[DomainVerification], domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_list(self, client: Gitpod) -> None: + response = client.organizations.domain_verifications.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain_verification = response.parse() + assert_matches_type(SyncDomainVerificationsPage[DomainVerification], domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_list(self, client: Gitpod) -> None: + with client.organizations.domain_verifications.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain_verification = response.parse() + assert_matches_type(SyncDomainVerificationsPage[DomainVerification], domain_verification, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_method_delete(self, client: Gitpod) -> None: + domain_verification = client.organizations.domain_verifications.delete() + assert_matches_type(object, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_delete_with_all_params(self, client: Gitpod) -> None: + domain_verification = client.organizations.domain_verifications.delete( + domain_verification_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(object, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_delete(self, client: Gitpod) -> None: + response = client.organizations.domain_verifications.with_raw_response.delete() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain_verification = response.parse() + assert_matches_type(object, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_delete(self, client: Gitpod) -> None: + with client.organizations.domain_verifications.with_streaming_response.delete() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain_verification = response.parse() + assert_matches_type(object, domain_verification, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + def test_method_verify(self, client: Gitpod) -> None: + domain_verification = client.organizations.domain_verifications.verify() + assert_matches_type(DomainVerificationVerifyResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_method_verify_with_all_params(self, client: Gitpod) -> None: + domain_verification = client.organizations.domain_verifications.verify( + domain_verification_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(DomainVerificationVerifyResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_raw_response_verify(self, client: Gitpod) -> None: + response = client.organizations.domain_verifications.with_raw_response.verify() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain_verification = response.parse() + assert_matches_type(DomainVerificationVerifyResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + def test_streaming_response_verify(self, client: Gitpod) -> None: + with client.organizations.domain_verifications.with_streaming_response.verify() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain_verification = response.parse() + assert_matches_type(DomainVerificationVerifyResponse, domain_verification, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncDomainVerifications: + parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip() + @parametrize + async def test_method_create(self, async_client: AsyncGitpod) -> None: + domain_verification = await async_client.organizations.domain_verifications.create() + assert_matches_type(DomainVerificationCreateResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_create_with_all_params(self, async_client: AsyncGitpod) -> None: + domain_verification = await async_client.organizations.domain_verifications.create( + domain="xxxx", + organization_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(DomainVerificationCreateResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_create(self, async_client: AsyncGitpod) -> None: + response = await async_client.organizations.domain_verifications.with_raw_response.create() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain_verification = await response.parse() + assert_matches_type(DomainVerificationCreateResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_create(self, async_client: AsyncGitpod) -> None: + async with async_client.organizations.domain_verifications.with_streaming_response.create() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain_verification = await response.parse() + assert_matches_type(DomainVerificationCreateResponse, domain_verification, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve(self, async_client: AsyncGitpod) -> None: + domain_verification = await async_client.organizations.domain_verifications.retrieve() + assert_matches_type(DomainVerificationRetrieveResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_retrieve_with_all_params(self, async_client: AsyncGitpod) -> None: + domain_verification = await async_client.organizations.domain_verifications.retrieve( + domain_verification_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(DomainVerificationRetrieveResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncGitpod) -> None: + response = await async_client.organizations.domain_verifications.with_raw_response.retrieve() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain_verification = await response.parse() + assert_matches_type(DomainVerificationRetrieveResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncGitpod) -> None: + async with async_client.organizations.domain_verifications.with_streaming_response.retrieve() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain_verification = await response.parse() + assert_matches_type(DomainVerificationRetrieveResponse, domain_verification, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_list(self, async_client: AsyncGitpod) -> None: + domain_verification = await async_client.organizations.domain_verifications.list() + assert_matches_type(AsyncDomainVerificationsPage[DomainVerification], domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncGitpod) -> None: + domain_verification = await async_client.organizations.domain_verifications.list( + token="token", + page_size=0, + organization_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + pagination={ + "token": "token", + "page_size": 100, + }, + ) + assert_matches_type(AsyncDomainVerificationsPage[DomainVerification], domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_list(self, async_client: AsyncGitpod) -> None: + response = await async_client.organizations.domain_verifications.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain_verification = await response.parse() + assert_matches_type(AsyncDomainVerificationsPage[DomainVerification], domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_list(self, async_client: AsyncGitpod) -> None: + async with async_client.organizations.domain_verifications.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain_verification = await response.parse() + assert_matches_type( + AsyncDomainVerificationsPage[DomainVerification], domain_verification, path=["response"] + ) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_delete(self, async_client: AsyncGitpod) -> None: + domain_verification = await async_client.organizations.domain_verifications.delete() + assert_matches_type(object, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_delete_with_all_params(self, async_client: AsyncGitpod) -> None: + domain_verification = await async_client.organizations.domain_verifications.delete( + domain_verification_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(object, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_delete(self, async_client: AsyncGitpod) -> None: + response = await async_client.organizations.domain_verifications.with_raw_response.delete() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain_verification = await response.parse() + assert_matches_type(object, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncGitpod) -> None: + async with async_client.organizations.domain_verifications.with_streaming_response.delete() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain_verification = await response.parse() + assert_matches_type(object, domain_verification, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip() + @parametrize + async def test_method_verify(self, async_client: AsyncGitpod) -> None: + domain_verification = await async_client.organizations.domain_verifications.verify() + assert_matches_type(DomainVerificationVerifyResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_method_verify_with_all_params(self, async_client: AsyncGitpod) -> None: + domain_verification = await async_client.organizations.domain_verifications.verify( + domain_verification_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(DomainVerificationVerifyResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_raw_response_verify(self, async_client: AsyncGitpod) -> None: + response = await async_client.organizations.domain_verifications.with_raw_response.verify() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + domain_verification = await response.parse() + assert_matches_type(DomainVerificationVerifyResponse, domain_verification, path=["response"]) + + @pytest.mark.skip() + @parametrize + async def test_streaming_response_verify(self, async_client: AsyncGitpod) -> None: + async with async_client.organizations.domain_verifications.with_streaming_response.verify() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + domain_verification = await response.parse() + assert_matches_type(DomainVerificationVerifyResponse, domain_verification, path=["response"]) + + assert cast(Any, response.is_closed) is True