growsurf-python 1.1.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

growsurf/_client.py

@@ -28,7 +28,7 @@ from ._compat import cached_property
 from ._models import SecurityOptions
 from ._version import __version__
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
-from ._exceptions import GrowsurfError, APIStatusError
+from ._exceptions import APIStatusError
 from ._base_client import (
     DEFAULT_MAX_RETRIES,
     SyncAPIClient,
@@ -36,7 +36,8 @@ from ._base_client import (
 )
 
 if TYPE_CHECKING:
-    from .resources import account, campaign
+    from .resources import team, account, campaign
+    from .resources.team import TeamResource, AsyncTeamResource
     from .resources.account import AccountResource, AsyncAccountResource
     from .resources.campaign.campaign import CampaignResource, AsyncCampaignResource
 
@@ -86,9 +87,7 @@ class Growsurf(SyncAPIClient):
         if api_key is None:
             api_key = os.environ.get("GROWSURF_API_KEY")
         if api_key is None:
-            raise GrowsurfError(
-                "The api_key client option must be set either by passing api_key to the client or by setting the GROWSURF_API_KEY environment variable"
-            )
+            api_key = ""
         self.api_key = api_key
 
         if base_url is None:
@@ -123,6 +122,12 @@ class Growsurf(SyncAPIClient):
 
         return AccountResource(self)
 
+    @cached_property
+    def team(self) -> TeamResource:
+        from .resources.team import TeamResource
+
+        return TeamResource(self)
+
     @cached_property
     def campaign(self) -> CampaignResource:
         from .resources.campaign import CampaignResource
@@ -153,6 +158,8 @@ class Growsurf(SyncAPIClient):
     @property
     def _api_key_auth(self) -> dict[str, str]:
         api_key = self.api_key
+        if not api_key:
+            return {}
         return {"Authorization": f"Bearer {api_key}"}
 
     @property
@@ -283,9 +290,7 @@ class AsyncGrowsurf(AsyncAPIClient):
         if api_key is None:
             api_key = os.environ.get("GROWSURF_API_KEY")
         if api_key is None:
-            raise GrowsurfError(
-                "The api_key client option must be set either by passing api_key to the client or by setting the GROWSURF_API_KEY environment variable"
-            )
+            api_key = ""
         self.api_key = api_key
 
         if base_url is None:
@@ -320,6 +325,12 @@ class AsyncGrowsurf(AsyncAPIClient):
 
         return AsyncAccountResource(self)
 
+    @cached_property
+    def team(self) -> AsyncTeamResource:
+        from .resources.team import AsyncTeamResource
+
+        return AsyncTeamResource(self)
+
     @cached_property
     def campaign(self) -> AsyncCampaignResource:
         from .resources.campaign import AsyncCampaignResource
@@ -350,6 +361,8 @@ class AsyncGrowsurf(AsyncAPIClient):
     @property
     def _api_key_auth(self) -> dict[str, str]:
         api_key = self.api_key
+        if not api_key:
+            return {}
         return {"Authorization": f"Bearer {api_key}"}
 
     @property
@@ -458,6 +471,12 @@ class GrowsurfWithRawResponse:
 
         return AccountResourceWithRawResponse(self._client.account)
 
+    @cached_property
+    def team(self) -> team.TeamResourceWithRawResponse:
+        from .resources.team import TeamResourceWithRawResponse
+
+        return TeamResourceWithRawResponse(self._client.team)
+
     @cached_property
     def campaign(self) -> campaign.CampaignResourceWithRawResponse:
         from .resources.campaign import CampaignResourceWithRawResponse
@@ -477,6 +496,12 @@ class AsyncGrowsurfWithRawResponse:
 
         return AsyncAccountResourceWithRawResponse(self._client.account)
 
+    @cached_property
+    def team(self) -> team.AsyncTeamResourceWithRawResponse:
+        from .resources.team import AsyncTeamResourceWithRawResponse
+
+        return AsyncTeamResourceWithRawResponse(self._client.team)
+
     @cached_property
     def campaign(self) -> campaign.AsyncCampaignResourceWithRawResponse:
         from .resources.campaign import AsyncCampaignResourceWithRawResponse
@@ -496,6 +521,12 @@ class GrowsurfWithStreamedResponse:
 
         return AccountResourceWithStreamingResponse(self._client.account)
 
+    @cached_property
+    def team(self) -> team.TeamResourceWithStreamingResponse:
+        from .resources.team import TeamResourceWithStreamingResponse
+
+        return TeamResourceWithStreamingResponse(self._client.team)
+
     @cached_property
     def campaign(self) -> campaign.CampaignResourceWithStreamingResponse:
         from .resources.campaign import CampaignResourceWithStreamingResponse
@@ -515,6 +546,12 @@ class AsyncGrowsurfWithStreamedResponse:
 
         return AsyncAccountResourceWithStreamingResponse(self._client.account)
 
+    @cached_property
+    def team(self) -> team.AsyncTeamResourceWithStreamingResponse:
+        from .resources.team import AsyncTeamResourceWithStreamingResponse
+
+        return AsyncTeamResourceWithStreamingResponse(self._client.team)
+
     @cached_property
     def campaign(self) -> campaign.AsyncCampaignResourceWithStreamingResponse:
         from .resources.campaign import AsyncCampaignResourceWithStreamingResponse

growsurf/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "growsurf"
-__version__ = "1.1.2"  # x-release-please-version
+__version__ = "1.2.0"  # x-release-please-version

growsurf/resources/__init__.py

@@ -1,5 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .team import (
+    TeamResource,
+    AsyncTeamResource,
+    TeamResourceWithRawResponse,
+    AsyncTeamResourceWithRawResponse,
+    TeamResourceWithStreamingResponse,
+    AsyncTeamResourceWithStreamingResponse,
+)
 from .account import (
     AccountResource,
     AsyncAccountResource,
@@ -24,6 +32,12 @@ __all__ = [
     "AsyncAccountResourceWithRawResponse",
     "AccountResourceWithStreamingResponse",
     "AsyncAccountResourceWithStreamingResponse",
+    "TeamResource",
+    "AsyncTeamResource",
+    "TeamResourceWithRawResponse",
+    "AsyncTeamResourceWithRawResponse",
+    "TeamResourceWithStreamingResponse",
+    "AsyncTeamResourceWithStreamingResponse",
     "CampaignResource",
     "AsyncCampaignResource",
     "CampaignResourceWithRawResponse",

growsurf/resources/account.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import httpx
 
-from ..types import account_create_params, account_update_params
+from ..types import account_create_params
 from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
 from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
@@ -16,34 +16,22 @@ from .._response import (
     async_to_streamed_response_wrapper,
 )
 from .._base_client import make_request_options
-from ..types.account import Account
 from ..types.create_account_response import CreateAccountResponse
-from ..types.rotate_api_key_response import RotateApiKeyResponse
-from ..types.verification_email_response import VerificationEmailResponse
 
 __all__ = ["AccountResource", "AsyncAccountResource"]
 
 
 class AccountResource(SyncAPIResource):
-    """Account operations for the account that owns the API key."""
+    """Create a GrowSurf account and its initial API key."""
 
     @cached_property
     def with_raw_response(self) -> AccountResourceWithRawResponse:
-        """
-        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/growsurf/growsurf-python#accessing-raw-response-data-eg-headers
-        """
+        """Return the raw response object instead of parsed content."""
         return AccountResourceWithRawResponse(self)
 
     @cached_property
     def with_streaming_response(self) -> AccountResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/growsurf/growsurf-python#with_streaming_response
-        """
+        """Stream the response instead of reading it eagerly."""
         return AccountResourceWithStreamingResponse(self)
 
     def create(
@@ -53,34 +41,25 @@ class AccountResource(SyncAPIResource):
         company: str | Omit = omit,
         first_name: str | Omit = omit,
         last_name: str | Omit = omit,
-        # 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,
     ) -> CreateAccountResponse:
-        """
-        Creates a new GrowSurf account. This is the only endpoint that does not require
-        an API key, so you can call it on a client constructed with any placeholder
-        `api_key`.
-
-        The response includes an API key for the new account, shown once in the
-        response. The key is locked until the account's email address is verified:
-        authenticated endpoints outside the Accounts group return a `403` with error
-        code `EMAIL_NOT_VERIFIED_ERROR`
-        until then (resend the email via the resend-verification-email endpoint, then
-        retry). A welcome email is sent to the address with the verification link and a
-        set-password link for dashboard access. Accounts whose email is never verified
-        are deleted automatically after 7 days. For security, the API key is rotated
-        the first time the account owner signs in to the GrowSurf dashboard. Some
-        actions (such as emailing participants) additionally require the GrowSurf team
-        to verify the account first. By creating an account you agree, on behalf of the
-        account holder, to GrowSurf's [Terms of Service](https://growsurf.com/terms) and
-        [Privacy Policy](https://growsurf.com/privacy).
+        """Create a GrowSurf account and return its one-time API key.
+
+        The key is locked until the team owner's email address is verified and rotates the
+        first time the account owner signs in to the GrowSurf dashboard. Accounts whose
+        email is never verified are deleted automatically after 7 days.
 
         Args:
-          email: The email address for the new account. Personal emails and disposable email addresses are not accepted.
+          email: The email address for the new GrowSurf account. Personal emails and disposable email addresses are not accepted.
+
+          company: Company name for the new account.
+
+          first_name: First name for the new account owner.
+
+          last_name: Last name for the new account owner.
 
           extra_headers: Send extra headers
 
@@ -102,174 +81,27 @@ class AccountResource(SyncAPIResource):
                 account_create_params.AccountCreateParams,
             ),
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                security={"api_key_auth": False},
             ),
             cast_to=CreateAccountResponse,
         )
 
-    def retrieve(
-        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,
-    ) -> Account:
-        """
-        Retrieves your GrowSurf account — profile and GrowSurf-team verification state.
-        `verificationStatus` is `VERIFIED` once the GrowSurf team has verified the
-        account — this is required before you can send participant emails from a program.
-        """
-        return self._get(
-            "/account",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Account,
-        )
-
-    def update(
-        self,
-        *,
-        company: str | Omit = omit,
-        first_name: str | Omit = omit,
-        last_name: str | Omit = omit,
-        # 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,
-    ) -> Account:
-        """
-        Updates your own account profile (`first_name`, `last_name`, `company`). Any
-        other property is rejected with a `400` — in particular, the account `email`
-        cannot be changed via the API, and billing/subscription is not editable here.
-
-        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._patch(
-            "/account",
-            body=maybe_transform(
-                {
-                    "company": company,
-                    "first_name": first_name,
-                    "last_name": last_name,
-                },
-                account_update_params.AccountUpdateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Account,
-        )
-
-    def rotate_api_key(
-        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,
-    ) -> RotateApiKeyResponse:
-        """
-        Generates a new API key and invalidates the key used for the request.
-
-        The SDK sends a retry-safe `Idempotency-Key`, so automatic retries return the
-        same replacement. Store the returned key, then update every integration that
-        used the old key. The account owner is notified by email whenever the key is
-        rotated. Requires an API key with `api_key:rotate`. This operation is available
-        only through the REST API or a GrowSurf API SDK, not through MCP.
-        """
-        return self._post(
-            "/account/api-key",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=RotateApiKeyResponse,
-        )
-
-    def request_verification(
-        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,
-    ) -> Account:
-        """
-        Requests GrowSurf-team verification of your account (required before a program can
-        email its participants). Idempotent — calling it again while a request is pending
-        does not create a duplicate. Returns the account with its updated
-        `verificationStatus`.
-        """
-        return self._post(
-            "/account/verification-request",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Account,
-        )
-
-    def resend_verification_email(
-        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,
-    ) -> VerificationEmailResponse:
-        """
-        Resends the email-verification email to the account's email address.
-
-        A `200` with `status: 'SENT'` is only returned when an email was actually
-        dispatched. Returns a `400` if the email is already verified, or a `429` if a
-        verification email was sent too recently — wait a moment, then retry.
-        """
-        return self._post(
-            "/account/verification-email",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=VerificationEmailResponse,
-        )
-
 
 class AsyncAccountResource(AsyncAPIResource):
-    """Account operations for the account that owns the API key."""
+    """Create a GrowSurf account and its initial API key."""
 
     @cached_property
     def with_raw_response(self) -> AsyncAccountResourceWithRawResponse:
-        """
-        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/growsurf/growsurf-python#accessing-raw-response-data-eg-headers
-        """
+        """Return the raw response object instead of parsed content."""
         return AsyncAccountResourceWithRawResponse(self)
 
     @cached_property
     def with_streaming_response(self) -> AsyncAccountResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/growsurf/growsurf-python#with_streaming_response
-        """
+        """Stream the response instead of reading it eagerly."""
         return AsyncAccountResourceWithStreamingResponse(self)
 
     async def create(
@@ -279,34 +111,25 @@ class AsyncAccountResource(AsyncAPIResource):
         company: str | Omit = omit,
         first_name: str | Omit = omit,
         last_name: str | Omit = omit,
-        # 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,
     ) -> CreateAccountResponse:
-        """
-        Creates a new GrowSurf account. This is the only endpoint that does not require
-        an API key, so you can call it on a client constructed with any placeholder
-        `api_key`.
-
-        The response includes an API key for the new account, shown once in the
-        response. The key is locked until the account's email address is verified:
-        authenticated endpoints outside the Accounts group return a `403` with error
-        code `EMAIL_NOT_VERIFIED_ERROR`
-        until then (resend the email via the resend-verification-email endpoint, then
-        retry). A welcome email is sent to the address with the verification link and a
-        set-password link for dashboard access. Accounts whose email is never verified
-        are deleted automatically after 7 days. For security, the API key is rotated
-        the first time the account owner signs in to the GrowSurf dashboard. Some
-        actions (such as emailing participants) additionally require the GrowSurf team
-        to verify the account first. By creating an account you agree, on behalf of the
-        account holder, to GrowSurf's [Terms of Service](https://growsurf.com/terms) and
-        [Privacy Policy](https://growsurf.com/privacy).
+        """Create a GrowSurf account and return its one-time API key.
+
+        The key is locked until the team owner's email address is verified and rotates the
+        first time the account owner signs in to the GrowSurf dashboard. Accounts whose
+        email is never verified are deleted automatically after 7 days.
 
         Args:
-          email: The email address for the new account. Personal emails and disposable email addresses are not accepted.
+          email: The email address for the new GrowSurf account. Personal emails and disposable email addresses are not accepted.
+
+          company: Company name for the new account.
+
+          first_name: First name for the new account owner.
+
+          last_name: Last name for the new account owner.
 
           extra_headers: Send extra headers
 
@@ -328,245 +151,35 @@ class AsyncAccountResource(AsyncAPIResource):
                 account_create_params.AccountCreateParams,
             ),
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                security={"api_key_auth": False},
             ),
             cast_to=CreateAccountResponse,
         )
 
-    async def retrieve(
-        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,
-    ) -> Account:
-        """
-        Retrieves your GrowSurf account — profile and GrowSurf-team verification state.
-        `verificationStatus` is `VERIFIED` once the GrowSurf team has verified the
-        account — this is required before you can send participant emails from a program.
-        """
-        return await self._get(
-            "/account",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Account,
-        )
-
-    async def update(
-        self,
-        *,
-        company: str | Omit = omit,
-        first_name: str | Omit = omit,
-        last_name: str | Omit = omit,
-        # 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,
-    ) -> Account:
-        """
-        Updates your own account profile (`first_name`, `last_name`, `company`). Any
-        other property is rejected with a `400` — in particular, the account `email`
-        cannot be changed via the API, and billing/subscription is not editable here.
-
-        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._patch(
-            "/account",
-            body=await async_maybe_transform(
-                {
-                    "company": company,
-                    "first_name": first_name,
-                    "last_name": last_name,
-                },
-                account_update_params.AccountUpdateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Account,
-        )
-
-    async def rotate_api_key(
-        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,
-    ) -> RotateApiKeyResponse:
-        """
-        Generates a new API key and invalidates the key used for the request.
-
-        The SDK sends a retry-safe `Idempotency-Key`, so automatic retries return the
-        same replacement. Store the returned key, then update every integration that
-        used the old key. The account owner is notified by email whenever the key is
-        rotated. Requires an API key with `api_key:rotate`. This operation is available
-        only through the REST API or a GrowSurf API SDK, not through MCP.
-        """
-        return await self._post(
-            "/account/api-key",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=RotateApiKeyResponse,
-        )
-
-    async def request_verification(
-        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,
-    ) -> Account:
-        """
-        Requests GrowSurf-team verification of your account (required before a program can
-        email its participants). Idempotent — calling it again while a request is pending
-        does not create a duplicate. Returns the account with its updated
-        `verificationStatus`.
-        """
-        return await self._post(
-            "/account/verification-request",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Account,
-        )
-
-    async def resend_verification_email(
-        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,
-    ) -> VerificationEmailResponse:
-        """
-        Resends the email-verification email to the account's email address.
-
-        A `200` with `status: 'SENT'` is only returned when an email was actually
-        dispatched. Returns a `400` if the email is already verified, or a `429` if a
-        verification email was sent too recently — wait a moment, then retry.
-        """
-        return await self._post(
-            "/account/verification-email",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=VerificationEmailResponse,
-        )
-
 
 class AccountResourceWithRawResponse:
     def __init__(self, account: AccountResource) -> None:
         self._account = account
-
-        self.create = to_raw_response_wrapper(
-            account.create,
-        )
-        self.retrieve = to_raw_response_wrapper(
-            account.retrieve,
-        )
-        self.update = to_raw_response_wrapper(
-            account.update,
-        )
-        self.rotate_api_key = to_raw_response_wrapper(
-            account.rotate_api_key,
-        )
-        self.request_verification = to_raw_response_wrapper(
-            account.request_verification,
-        )
-        self.resend_verification_email = to_raw_response_wrapper(
-            account.resend_verification_email,
-        )
+        self.create = to_raw_response_wrapper(account.create)
 
 
 class AsyncAccountResourceWithRawResponse:
     def __init__(self, account: AsyncAccountResource) -> None:
         self._account = account
-
-        self.create = async_to_raw_response_wrapper(
-            account.create,
-        )
-        self.retrieve = async_to_raw_response_wrapper(
-            account.retrieve,
-        )
-        self.update = async_to_raw_response_wrapper(
-            account.update,
-        )
-        self.rotate_api_key = async_to_raw_response_wrapper(
-            account.rotate_api_key,
-        )
-        self.request_verification = async_to_raw_response_wrapper(
-            account.request_verification,
-        )
-        self.resend_verification_email = async_to_raw_response_wrapper(
-            account.resend_verification_email,
-        )
+        self.create = async_to_raw_response_wrapper(account.create)
 
 
 class AccountResourceWithStreamingResponse:
     def __init__(self, account: AccountResource) -> None:
         self._account = account
-
-        self.create = to_streamed_response_wrapper(
-            account.create,
-        )
-        self.retrieve = to_streamed_response_wrapper(
-            account.retrieve,
-        )
-        self.update = to_streamed_response_wrapper(
-            account.update,
-        )
-        self.rotate_api_key = to_streamed_response_wrapper(
-            account.rotate_api_key,
-        )
-        self.request_verification = to_streamed_response_wrapper(
-            account.request_verification,
-        )
-        self.resend_verification_email = to_streamed_response_wrapper(
-            account.resend_verification_email,
-        )
+        self.create = to_streamed_response_wrapper(account.create)
 
 
 class AsyncAccountResourceWithStreamingResponse:
     def __init__(self, account: AsyncAccountResource) -> None:
         self._account = account
-
-        self.create = async_to_streamed_response_wrapper(
-            account.create,
-        )
-        self.retrieve = async_to_streamed_response_wrapper(
-            account.retrieve,
-        )
-        self.update = async_to_streamed_response_wrapper(
-            account.update,
-        )
-        self.rotate_api_key = async_to_streamed_response_wrapper(
-            account.rotate_api_key,
-        )
-        self.request_verification = async_to_streamed_response_wrapper(
-            account.request_verification,
-        )
-        self.resend_verification_email = async_to_streamed_response_wrapper(
-            account.resend_verification_email,
-        )
+        self.create = async_to_streamed_response_wrapper(account.create)

growsurf/resources/campaign/campaign.py

@@ -198,7 +198,7 @@ class CampaignResource(SyncAPIResource):
         """
         Creates a new program pre-populated with type-appropriate defaults, plus any
         optional inline rewards. The new program is created in `DRAFT` status and owned
-        by the API key's account. Requires a verified account email.
+        by the API key's bound team. Requires the team owner's verified email.
 
         Args:
           type: The program type. Immutable after creation.
@@ -900,7 +900,7 @@ class AsyncCampaignResource(AsyncAPIResource):
         """
         Creates a new program pre-populated with type-appropriate defaults, plus any
         optional inline rewards. The new program is created in `DRAFT` status and owned
-        by the API key's account. Requires a verified account email.
+        by the API key's bound team. Requires the team owner's verified email.
 
         Args:
           type: The program type. Immutable after creation.

growsurf/resources/campaign/participant.py

@@ -980,8 +980,8 @@ class ParticipantResource(SyncAPIResource):
         the program's configured email templates, OR ``subject`` + ``body`` for a
         free-form email. Free-form emails are sent with the same compliance handling
         (company name, postal address, and an unsubscribe link are added automatically,
-        and unsubscribed participants are suppressed). Sending requires the account to be
-        verified by the GrowSurf team. Requires a verified custom email domain on the
+        and unsubscribed participants are suppressed). Sending requires the team to be
+        verified by GrowSurf. Requires a verified custom email domain on the
         program (set up in Campaign Editor > 3. Emails > Email Settings). Returns `400`
         until one is verified. The email is accepted for delivery.
 
@@ -2099,8 +2099,8 @@ class AsyncParticipantResource(AsyncAPIResource):
         the program's configured email templates, OR ``subject`` + ``body`` for a
         free-form email. Free-form emails are sent with the same compliance handling
         (company name, postal address, and an unsubscribe link are added automatically,
-        and unsubscribed participants are suppressed). Sending requires the account to be
-        verified by the GrowSurf team. Requires a verified custom email domain on the
+        and unsubscribed participants are suppressed). Sending requires the team to be
+        verified by GrowSurf. Requires a verified custom email domain on the
         program (set up in Campaign Editor > 3. Emails > Email Settings). Returns `400`
         until one is verified. The email is accepted for delivery.
 

growsurf/resources/team.py

@@ -0,0 +1,323 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import team_update_params
+from .._types import Body, Query, Headers, NotGiven, not_given
+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 ..types.team import Team
+from .._base_client import make_request_options
+from ..types.rotate_api_key_response import RotateApiKeyResponse
+from ..types.verification_email_response import VerificationEmailResponse
+
+__all__ = ["TeamResource", "AsyncTeamResource"]
+
+
+class TeamResource(SyncAPIResource):
+    """Operations for the team bound to the API key or OAuth connection."""
+
+    @cached_property
+    def with_raw_response(self) -> TeamResourceWithRawResponse:
+        """Return the raw response object instead of parsed content."""
+        return TeamResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> TeamResourceWithStreamingResponse:
+        """Stream the response instead of reading it eagerly."""
+        return TeamResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        *,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Team:
+        """Retrieve the team bound to the API key or OAuth connection.
+
+        A credential that can act across multiple teams cannot use this operation because
+        it has no single Team resource.
+        """
+        return self._get(
+            "/team",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Team,
+        )
+
+    def update(
+        self,
+        *,
+        name: str,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Team:
+        """Update the bound team's display name.
+
+        Any other property is rejected with a `400`.
+
+        Args:
+          name: The team's display name.
+
+          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._patch(
+            "/team",
+            body=maybe_transform({"name": name}, team_update_params.TeamUpdateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Team,
+        )
+
+    def rotate_api_key(
+        self,
+        *,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RotateApiKeyResponse:
+        """Rotate the API key used for this request.
+
+        The SDK sends a retry-safe `Idempotency-Key`, so automatic retries return the
+        same replacement. Store the new key, then update every integration that used the
+        old key. This operation is unavailable through MCP.
+        """
+        return self._post(
+            "/api-key/rotate",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RotateApiKeyResponse,
+        )
+
+    def request_verification(
+        self,
+        *,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Team:
+        """Request GrowSurf verification for the bound team.
+
+        Calling this again while a request is pending does not create a duplicate.
+        """
+        return self._post(
+            "/team/verification-request",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Team,
+        )
+
+    def resend_owner_verification_email(
+        self,
+        *,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VerificationEmailResponse:
+        """Resend the email-verification message to the bound team's owner.
+
+        The response never reveals the owner's email address.
+        """
+        return self._post(
+            "/team/owner/verification-email",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VerificationEmailResponse,
+        )
+
+
+class AsyncTeamResource(AsyncAPIResource):
+    """Operations for the team bound to the API key or OAuth connection."""
+
+    @cached_property
+    def with_raw_response(self) -> AsyncTeamResourceWithRawResponse:
+        """Return the raw response object instead of parsed content."""
+        return AsyncTeamResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncTeamResourceWithStreamingResponse:
+        """Stream the response instead of reading it eagerly."""
+        return AsyncTeamResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        *,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Team:
+        """Retrieve the team bound to the API key or OAuth connection.
+
+        A credential that can act across multiple teams cannot use this operation because
+        it has no single Team resource.
+        """
+        return await self._get(
+            "/team",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Team,
+        )
+
+    async def update(
+        self,
+        *,
+        name: str,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Team:
+        """Update the bound team's display name.
+
+        Any other property is rejected with a `400`.
+
+        Args:
+          name: The team's display name.
+
+          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._patch(
+            "/team",
+            body=await async_maybe_transform({"name": name}, team_update_params.TeamUpdateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Team,
+        )
+
+    async def rotate_api_key(
+        self,
+        *,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RotateApiKeyResponse:
+        """Rotate the API key used for this request.
+
+        The SDK sends a retry-safe `Idempotency-Key`, so automatic retries return the
+        same replacement. Store the new key, then update every integration that used the
+        old key. This operation is unavailable through MCP.
+        """
+        return await self._post(
+            "/api-key/rotate",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RotateApiKeyResponse,
+        )
+
+    async def request_verification(
+        self,
+        *,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Team:
+        """Request GrowSurf verification for the bound team.
+
+        Calling this again while a request is pending does not create a duplicate.
+        """
+        return await self._post(
+            "/team/verification-request",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Team,
+        )
+
+    async def resend_owner_verification_email(
+        self,
+        *,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VerificationEmailResponse:
+        """Resend the email-verification message to the bound team's owner.
+
+        The response never reveals the owner's email address.
+        """
+        return await self._post(
+            "/team/owner/verification-email",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VerificationEmailResponse,
+        )
+
+
+class TeamResourceWithRawResponse:
+    def __init__(self, team: TeamResource) -> None:
+        self._team = team
+        self.retrieve = to_raw_response_wrapper(team.retrieve)
+        self.update = to_raw_response_wrapper(team.update)
+        self.rotate_api_key = to_raw_response_wrapper(team.rotate_api_key)
+        self.request_verification = to_raw_response_wrapper(team.request_verification)
+        self.resend_owner_verification_email = to_raw_response_wrapper(team.resend_owner_verification_email)
+
+
+class AsyncTeamResourceWithRawResponse:
+    def __init__(self, team: AsyncTeamResource) -> None:
+        self._team = team
+        self.retrieve = async_to_raw_response_wrapper(team.retrieve)
+        self.update = async_to_raw_response_wrapper(team.update)
+        self.rotate_api_key = async_to_raw_response_wrapper(team.rotate_api_key)
+        self.request_verification = async_to_raw_response_wrapper(team.request_verification)
+        self.resend_owner_verification_email = async_to_raw_response_wrapper(team.resend_owner_verification_email)
+
+
+class TeamResourceWithStreamingResponse:
+    def __init__(self, team: TeamResource) -> None:
+        self._team = team
+        self.retrieve = to_streamed_response_wrapper(team.retrieve)
+        self.update = to_streamed_response_wrapper(team.update)
+        self.rotate_api_key = to_streamed_response_wrapper(team.rotate_api_key)
+        self.request_verification = to_streamed_response_wrapper(team.request_verification)
+        self.resend_owner_verification_email = to_streamed_response_wrapper(team.resend_owner_verification_email)
+
+
+class AsyncTeamResourceWithStreamingResponse:
+    def __init__(self, team: AsyncTeamResource) -> None:
+        self._team = team
+        self.retrieve = async_to_streamed_response_wrapper(team.retrieve)
+        self.update = async_to_streamed_response_wrapper(team.update)
+        self.rotate_api_key = async_to_streamed_response_wrapper(team.rotate_api_key)
+        self.request_verification = async_to_streamed_response_wrapper(team.request_verification)
+        self.resend_owner_verification_email = async_to_streamed_response_wrapper(team.resend_owner_verification_email)

growsurf/types/__init__.py

@@ -2,13 +2,13 @@
 
 from __future__ import annotations
 
-from .account import Account as Account
+from .team import Team as Team
 from .campaign import Campaign as Campaign
 from .referral_list import ReferralList as ReferralList
 from .participant_list import ParticipantList as ParticipantList
+from .team_update_params import TeamUpdateParams as TeamUpdateParams
 from .commission_structure import CommissionStructure as CommissionStructure
 from .account_create_params import AccountCreateParams as AccountCreateParams
-from .account_update_params import AccountUpdateParams as AccountUpdateParams
 from .campaign_create_params import CampaignCreateParams as CampaignCreateParams
 from .campaign_list_response import CampaignListResponse as CampaignListResponse
 from .campaign_update_params import CampaignUpdateParams as CampaignUpdateParams

growsurf/types/create_account_response.py

@@ -10,17 +10,19 @@ __all__ = ["CreateAccountResponse"]
 
 
 class CreateAccountResponse(BaseModel):
-    id: str
-    """The new account's unique identifier."""
-
     email: str
+    """Email address for the new account."""
 
     api_key: str = FieldInfo(alias="apiKey")
     """An API key for the new account.
 
-    Use it as the `Bearer` token on subsequent requests. Locked (`403`
-    `EMAIL_NOT_VERIFIED_ERROR`) until the account's email is verified, and rotated
-    when the account owner first signs in to the GrowSurf dashboard.
+    Use it as the `Bearer` token on subsequent requests. It is shown once, locked
+    (`403` `EMAIL_NOT_VERIFIED_ERROR`) until the account's email is verified, and
+    rotated when the account owner first signs in to the GrowSurf dashboard.
     """
 
     verification_status: Literal["NOT_REQUESTED", "REQUESTED", "VERIFIED"] = FieldInfo(alias="verificationStatus")
+    """GrowSurf team verification state.
+
+    `VERIFIED` is required before a program can send participant emails.
+    """

growsurf/types/{account.py → team.py}

@@ -7,29 +7,18 @@ from pydantic import Field as FieldInfo
 
 from .._models import BaseModel
 
-__all__ = ["Account"]
+__all__ = ["Team"]
 
 
-class Account(BaseModel):
-    id: str
-    """The account's unique identifier."""
-
-    email: str
+class Team(BaseModel):
+    name: str
+    """The team's display name."""
 
     verification_status: Literal["NOT_REQUESTED", "REQUESTED", "VERIFIED"] = FieldInfo(alias="verificationStatus")
-    """GrowSurf-team verification state.
+    """GrowSurf team verification state.
 
     `VERIFIED` is required before a program can send participant emails.
     """
 
-    company: Optional[str] = None
-
-    created_at: Optional[int] = FieldInfo(alias="createdAt", default=None)
-    """When the account was created, as a Unix timestamp in milliseconds."""
-
-    first_name: Optional[str] = FieldInfo(alias="firstName", default=None)
-
-    last_name: Optional[str] = FieldInfo(alias="lastName", default=None)
-
-    verification_requested_at: Optional[int] = FieldInfo(alias="verificationRequestedAt", default=None)
+    verification_requested_at: Optional[int] = FieldInfo(alias="verificationRequestedAt")
     """When team verification was last requested, as a Unix timestamp in milliseconds."""

growsurf/types/team_update_params.py

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["TeamUpdateParams"]
+
+
+class TeamUpdateParams(TypedDict, total=False):
+    name: Required[str]
+    """The team's display name."""

{growsurf_python-1.1.2.dist-info → growsurf_python-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: growsurf-python
-Version: 1.1.2
+Version: 1.2.0
 Summary: The official Python library for the growsurf API
 Project-URL: Homepage, https://github.com/growsurf/growsurf-python
 Project-URL: Repository, https://github.com/growsurf/growsurf-python

{growsurf_python-1.1.2.dist-info → growsurf_python-1.2.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 growsurf/__init__.py,sha256=PVU29rH3G7u2LvpyJd5G00W8Saj2Cp_BNzw7JIg8068,2683
 growsurf/_base_client.py,sha256=4kz0Jq20J5tuau3uZ9dLIBp-EotPbXDIJ5AQ4rTE7AA,74561
-growsurf/_client.py,sha256=suOVygcmn3NqVYwXaN4wzRYn3u0Yf9iecTpDaBzf7d0,19331
+growsurf/_client.py,sha256=hrl6UKIUtUzBwZR-vaQRrZglj5sFz8px-jJ6KVQ7y-0,20315
 growsurf/_compat.py,sha256=_9guQfzYnL3DNtudX5W7T2cdSskx89B5AFfhPQDxMUk,6811
 growsurf/_constants.py,sha256=S14PFzyN9-I31wiV7SmIlL5Ga0MLHxdvegInGdXH7tM,462
 growsurf/_exceptions.py,sha256=3bEzw4WDc3VYTMnwkiOucauRjS8Vhr3L0Qb02P0ZKaE,3224
@@ -11,7 +11,7 @@ growsurf/_resource.py,sha256=oeDA0FL2ottIchoUi86M_8eUqmtrGQLYTgfKYEzrsWg,1112
 growsurf/_response.py,sha256=RTZ8t27W4S6ExkCjzCg4HbcDUTCdOMgiheiMAuAxgu4,28937
 growsurf/_streaming.py,sha256=9aJ_V6JtddntWCon2Cq_MOLMnySnhc7wuqeZx7sUtKU,10558
 growsurf/_types.py,sha256=r8hAVihrutiLUToaJhSDys9T9sMc8BMy2qUrr3W_8Wo,7751
-growsurf/_version.py,sha256=8sTKEyG6dzm-lh9DQJ-rPuFC2-kMk2irKInDZRAzlKQ,160
+growsurf/_version.py,sha256=OWpo4konL_MQCWCiNFp1FuwA_WcSPNEK3iIIKN7x7aM,160
 growsurf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 growsurf/_utils/__init__.py,sha256=nQq-iFa5YxTaWySaLigatew5rHgTR0M75FNYm4mrO1s,2313
 growsurf/_utils/_compat.py,sha256=33246eDcl3pwL6kWsEhVuT4Akrd8gZEW9LPTm465ohk,1231
@@ -28,23 +28,22 @@ growsurf/_utils/_transform.py,sha256=NjCzmnfqYrsAikUHQig6N9QfuTVbKipuP3ur9mcNF-E
 growsurf/_utils/_typing.py,sha256=N_5PPuFNsaygbtA_npZd98SVN1LQQvFTKL6bkWPBZGU,4786
 growsurf/_utils/_utils.py,sha256=2nPOzDrPe2GADpLCRM4bNQS8Mu7LjEiCG_LJ2AAL6jg,13111
 growsurf/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
-growsurf/resources/__init__.py,sha256=svo5sO2EsnyOM5xM5o8_U1aiqywVAO94WN1nTT156I4,1041
-growsurf/resources/account.py,sha256=2t0yIO0MUaqfuXJpTtLBqlan3qJoVXal2HRlA0peOq4,24461
+growsurf/resources/__init__.py,sha256=RYj6vjnPpErdBftiCuJtbwqGAnll4jXw6sg4qh6o988,1465
+growsurf/resources/account.py,sha256=dcSGZl3B0zgvDwdb8_RC0rBJXhs6pMwEDePWEiOZuNc,6727
+growsurf/resources/team.py,sha256=D6Qs011ggaeqOHW8aZRAPvgGVG4JRqVPq626ptvWGg4,12339
 growsurf/resources/campaign/__init__.py,sha256=XW5nmnR2dF-wzM0d9aoF5cZDC7c-XyyIOjdmPV8IPZ8,4875
-growsurf/resources/campaign/campaign.py,sha256=4-sl6-D0Q68d1Al-_33MPZhKaqF5YFbQeqwhcmcaEk8,75401
+growsurf/resources/campaign/campaign.py,sha256=pUW-O7y3B5pfuQyv9xsDRWkRKXnuQuFvEIsjAweqURI,75421
 growsurf/resources/campaign/commission.py,sha256=K5HmznRM7nO-VNiP2Jy1rIeW63rAx1Aa2M9DEJ9dB2I,10294
 growsurf/resources/campaign/design.py,sha256=H2Syg6ASogYxrPRB9YG4VhQtGp89FRJm-AQOu5g572U,10762
 growsurf/resources/campaign/emails.py,sha256=wGGP1hTPKGb-O7wRAvkGsMflKaoPMhpXyq2ZPfJ-Xng,11060
 growsurf/resources/campaign/installation.py,sha256=36WbjO6ZDh_dDR4VHLNRxrgjbtkwYb6CbaPSc3KdbSw,11234
 growsurf/resources/campaign/options.py,sha256=OfXOBysKf7VW3IJFv7bSOcPnMXSETolRGiV2n6Ff0pQ,11130
-growsurf/resources/campaign/participant.py,sha256=ADDC6f5K8UW-ihsU5rwYHJVOWwPNVn4KOyq1JlWWfro,106610
+growsurf/resources/campaign/participant.py,sha256=4a8fU_nNTMa1txWG9eNXKybNPrT3N-lwl20BwHpHAoo,106586
 growsurf/resources/campaign/reward.py,sha256=CLRzQywVF6zpjVG2S4OIKyBhaS9B9Obrjk6ENOicb30,14264
 growsurf/resources/campaign/rewards.py,sha256=x-fZvvo0gx--SEw_r1t6HHEr6aU5Ir4kh2pqFTsxiqw,34425
 growsurf/resources/campaign/webhooks.py,sha256=DRJ8-8QDibGEq1hT7MTkrlE5kdbEapZXiZb2z_kKM68,22666
-growsurf/types/__init__.py,sha256=Yj4kkVWCtct-IM6FrmErkEjJSVWuzsdszLFHs8FSk2w,2335
-growsurf/types/account.py,sha256=Xd4rIMf7cLytYWQW6uCia0wlbKQ1kmsMBoGOe7eHXtU,1121
+growsurf/types/__init__.py,sha256=Au2V8z6APUZOYt-Lyy5X34gODWokEk_4jTWVnCmcZTg,2317
 growsurf/types/account_create_params.py,sha256=BXaWsGsiiSbYvVy6ftPNwu7nA2m1xI4PvE1xGEoGeCo,602
-growsurf/types/account_update_params.py,sha256=FUC-dkZFJcpsWHjJ5iWTF_URSIeTiuNsimKL1oANwsQ,442
 growsurf/types/campaign_create_mobile_participant_token_params.py,sha256=oiyxZZGwlGdBSb-4s8FonLXyl_SIPdLECa4a0vrRXso,1248
 growsurf/types/campaign_create_mobile_participant_token_response.py,sha256=IvIgtizBufLI-p9pk7MnyJj3XydHjLvdoAw-PWpPqdI,769
 growsurf/types/campaign_create_params.py,sha256=JQfKq7xZLIbFRzQvEgtSCNPr3okVLiM1ctIHtcE2ihI,1080
@@ -58,12 +57,14 @@ growsurf/types/campaign_retrieve_analytics_params.py,sha256=VqYCmKvdz9vVaLFL5jo5
 growsurf/types/campaign_retrieve_analytics_response.py,sha256=xBVhUYHD0IHM1ZDLi7kaOXe7Mm21hnTCSrvxpE_Q4Bc,7367
 growsurf/types/campaign_update_params.py,sha256=_MijTVkSXi5nP_k1ch2QXDKnIVxxKT1ChuxhgbmcdMc,681
 growsurf/types/commission_structure.py,sha256=oqAryQHyMPQIM6DjvbPR_mNF5UdtXp_M86P2zrhVi8g,2398
-growsurf/types/create_account_response.py,sha256=JOVmdscTHMWI8yGpIDUM-7cW3XtHMQo7zJFfxPoL6t0,786
+growsurf/types/create_account_response.py,sha256=sVvx_HUgdL3emzCednvPDOakRRTc-jETgZxrGTOHbjk,912
 growsurf/types/participant_commission_list.py,sha256=NodpaTxYHY30DNfBp3m09BPv0Zu50gJtpjJ0stpE6fk,1896
 growsurf/types/participant_list.py,sha256=5oety8iTXx5anr0W5wAjzCAIMPkQLPeVIc2TNuRbrMY,430
 growsurf/types/participant_payout_list.py,sha256=93fM0_gS3ej8KbEpkEPsU8GHWnV-un0duWkuxePr_IQ,1493
 growsurf/types/referral_list.py,sha256=SOU3s0cjeQLhbZVbeGoeCprVyrPTk-tvmMBMV25uG1o,969
 growsurf/types/rotate_api_key_response.py,sha256=dzF80t7wkpHAso5u9QciHNzYww3qTsEmE9LJ4XAQPGM,376
+growsurf/types/team.py,sha256=m7_7iAbceXcnryJClCOkcUbvG1MeMoIDb9fEy_8JXcA,741
+growsurf/types/team_update_params.py,sha256=BWe-y5FywSFF3z-riG2cd3qkZTqhbjeLBj_wmiMArbc,278
 growsurf/types/verification_email_response.py,sha256=UYhx3DiXpWWgumukaezuiuIq_OME-3QE2_vG0TnwR00,292
 growsurf/types/campaign/__init__.py,sha256=cRjsIrPhEbMXTyyWY0IWanGk1SUgRd1IJUd7_9kOoC8,4944
 growsurf/types/campaign/campaign.py,sha256=Mm2bYeZnGFnghAPxvXPPhrbq8fzqAiqjeyDd-u9tP_E,3111
@@ -120,7 +121,7 @@ growsurf/types/campaign/webhook_list_response.py,sha256=tSk9nTbcsj5Y-j4RjQwu9SZc
 growsurf/types/campaign/webhook_test_params.py,sha256=X1Osg9-4KGJbZauG_7rDqTE7cKCypeSzgumIhnxj9dk,468
 growsurf/types/campaign/webhook_test_response.py,sha256=AahcckKSLUeIgpwlosOOmbkioF62xREXgLbieHAPAdI,576
 growsurf/types/campaign/webhook_update_params.py,sha256=SavKhws8pfybC7O40ovtCreEmOwihEGPOCEX9Iua9cE,598
-growsurf_python-1.1.2.dist-info/METADATA,sha256=NGZ9XyRKo6pp1Ovkml1j0KUDOODoZ6FGDe4G78Gvoaw,13614
-growsurf_python-1.1.2.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-growsurf_python-1.1.2.dist-info/licenses/LICENSE,sha256=kTHLVE-ra1gtTxcn395uFqcOzcErebE-mDdPNW7b8OU,11338
-growsurf_python-1.1.2.dist-info/RECORD,,
+growsurf_python-1.2.0.dist-info/METADATA,sha256=qGVu3HTUNcU26QnNkT9VzK0nnQllwmV63d6NSG1or5U,13614
+growsurf_python-1.2.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+growsurf_python-1.2.0.dist-info/licenses/LICENSE,sha256=kTHLVE-ra1gtTxcn395uFqcOzcErebE-mDdPNW7b8OU,11338
+growsurf_python-1.2.0.dist-info/RECORD,,

growsurf/types/account_update_params.py

@@ -1,17 +0,0 @@
-# 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__ = ["AccountUpdateParams"]
-
-
-class AccountUpdateParams(TypedDict, total=False):
-    company: str
-
-    first_name: Annotated[str, PropertyInfo(alias="firstName")]
-
-    last_name: Annotated[str, PropertyInfo(alias="lastName")]