types-auth0-python 4.8.0.20250404__py3-none-any.whl

auth0-stubs/METADATA.toml

@@ -0,0 +1,3 @@
+version = "4.8.*"
+upstream_repository = "https://github.com/auth0/auth0-python"
+requires = ["cryptography", "types-requests"]

auth0-stubs/__init__.pyi

@@ -0,0 +1,7 @@
+from auth0.exceptions import (
+    Auth0Error as Auth0Error,
+    RateLimitError as RateLimitError,
+    TokenValidationError as TokenValidationError,
+)
+
+__all__ = ("Auth0Error", "RateLimitError", "TokenValidationError")

auth0-stubs/asyncify.pyi

@@ -0,0 +1,6 @@
+from auth0.authentication import Users as Users
+from auth0.authentication.base import AuthenticationBase as AuthenticationBase
+from auth0.rest import RestClientOptions as RestClientOptions
+from auth0.rest_async import AsyncRestClient as AsyncRestClient
+
+def asyncify(cls): ...

auth0-stubs/authentication/__init__.pyi

@@ -0,0 +1,10 @@
+from .database import Database as Database
+from .delegated import Delegated as Delegated
+from .enterprise import Enterprise as Enterprise
+from .get_token import GetToken as GetToken
+from .passwordless import Passwordless as Passwordless
+from .revoke_token import RevokeToken as RevokeToken
+from .social import Social as Social
+from .users import Users as Users
+
+__all__ = ("Database", "Delegated", "Enterprise", "GetToken", "Passwordless", "RevokeToken", "Social", "Users")

auth0-stubs/authentication/async_token_verifier.pyi

@@ -0,0 +1,27 @@
+from _typeshed import Incomplete
+
+from .. import TokenValidationError as TokenValidationError
+from ..rest_async import AsyncRestClient as AsyncRestClient
+from .token_verifier import (
+    AsymmetricSignatureVerifier as AsymmetricSignatureVerifier,
+    JwksFetcher as JwksFetcher,
+    TokenVerifier as TokenVerifier,
+)
+
+class AsyncAsymmetricSignatureVerifier(AsymmetricSignatureVerifier):
+    def __init__(self, jwks_url: str, algorithm: str = "RS256") -> None: ...
+    def set_session(self, session) -> None: ...
+
+class AsyncJwksFetcher(JwksFetcher):
+    def __init__(self, *args, **kwargs) -> None: ...
+    def set_session(self, session) -> None: ...
+    async def get_key(self, key_id: str): ...
+
+class AsyncTokenVerifier(TokenVerifier):
+    iss: Incomplete
+    aud: Incomplete
+    leeway: Incomplete
+    def __init__(
+        self, signature_verifier: AsyncAsymmetricSignatureVerifier, issuer: str, audience: str, leeway: int = 0
+    ) -> None: ...
+    def set_session(self, session) -> None: ...

auth0-stubs/authentication/back_channel_login.pyi

@@ -0,0 +1,4 @@
+from .base import AuthenticationBase as AuthenticationBase
+
+class BackChannelLogin(AuthenticationBase):
+    def back_channel_login(self, binding_message: str, login_hint: str, scope: str, **kwargs): ...

auth0-stubs/authentication/base.pyi

@@ -0,0 +1,31 @@
+from _typeshed import Incomplete
+
+from auth0.rest import RestClient as RestClient, RestClientOptions as RestClientOptions
+from auth0.types import RequestData as RequestData
+
+from .client_authentication import add_client_authentication as add_client_authentication
+
+UNKNOWN_ERROR: str
+
+class AuthenticationBase:
+    domain: Incomplete
+    client_id: Incomplete
+    client_secret: Incomplete
+    client_assertion_signing_key: Incomplete
+    client_assertion_signing_alg: Incomplete
+    protocol: Incomplete
+    client: Incomplete
+    def __init__(
+        self,
+        domain: str,
+        client_id: str,
+        client_secret: str | None = None,
+        client_assertion_signing_key: str | None = None,
+        client_assertion_signing_alg: str | None = None,
+        telemetry: bool = True,
+        timeout: float | tuple[float, float] = 5.0,
+        protocol: str = "https",
+    ) -> None: ...
+    def post(self, url: str, data: RequestData | None = None, headers: dict[str, str] | None = None): ...
+    def authenticated_post(self, url: str, data: dict[str, Incomplete], headers: dict[str, str] | None = None): ...
+    def get(self, url: str, params: dict[str, Incomplete] | None = None, headers: dict[str, str] | None = None): ...

auth0-stubs/authentication/client_authentication.pyi

@@ -0,0 +1,13 @@
+from _typeshed import Incomplete
+
+def create_client_assertion_jwt(
+    domain: str, client_id: str, client_assertion_signing_key: str, client_assertion_signing_alg: str | None
+) -> str: ...
+def add_client_authentication(
+    payload: dict[str, Incomplete],
+    domain: str,
+    client_id: str,
+    client_secret: str | None,
+    client_assertion_signing_key: str | None,
+    client_assertion_signing_alg: str | None,
+) -> dict[str, Incomplete]: ...

auth0-stubs/authentication/database.pyi

@@ -0,0 +1,21 @@
+from _typeshed import Incomplete
+
+from .base import AuthenticationBase as AuthenticationBase
+
+class Database(AuthenticationBase):
+    def signup(
+        self,
+        email: str,
+        password: str,
+        connection: str,
+        username: str | None = None,
+        user_metadata: dict[str, Incomplete] | None = None,
+        given_name: str | None = None,
+        family_name: str | None = None,
+        name: str | None = None,
+        nickname: str | None = None,
+        picture: str | None = None,
+    ) -> dict[str, Incomplete]: ...
+    def change_password(
+        self, email: str, connection: str, password: str | None = None, organization: str | None = None
+    ) -> str: ...

auth0-stubs/authentication/delegated.pyi

@@ -0,0 +1,12 @@
+from .base import AuthenticationBase as AuthenticationBase
+
+class Delegated(AuthenticationBase):
+    def get_token(
+        self,
+        target: str,
+        api_type: str,
+        grant_type: str,
+        id_token: str | None = None,
+        refresh_token: str | None = None,
+        scope: str = "openid",
+    ): ...

auth0-stubs/authentication/enterprise.pyi

@@ -0,0 +1,5 @@
+from .base import AuthenticationBase as AuthenticationBase
+
+class Enterprise(AuthenticationBase):
+    def saml_metadata(self): ...
+    def wsfed_metadata(self): ...

auth0-stubs/authentication/get_token.pyi

@@ -0,0 +1,21 @@
+from .base import AuthenticationBase as AuthenticationBase
+
+class GetToken(AuthenticationBase):
+    def authorization_code(self, code: str, redirect_uri: str | None, grant_type: str = "authorization_code"): ...
+    def authorization_code_pkce(
+        self, code_verifier: str, code: str, redirect_uri: str | None, grant_type: str = "authorization_code"
+    ): ...
+    def client_credentials(self, audience: str, grant_type: str = "client_credentials", organization: str | None = None): ...
+    def login(
+        self,
+        username: str,
+        password: str,
+        scope: str | None = None,
+        realm: str | None = None,
+        audience: str | None = None,
+        grant_type: str = "http://auth0.com/oauth/grant-type/password-realm",
+        forwarded_for: str | None = None,
+    ): ...
+    def refresh_token(self, refresh_token: str, scope: str = "", grant_type: str = "refresh_token"): ...
+    def passwordless_login(self, username: str, otp: str, realm: str, scope: str, audience: str): ...
+    def backchannel_login(self, auth_req_id: str, grant_type: str = "urn:openid:params:grant-type:ciba"): ...

auth0-stubs/authentication/passwordless.pyi

@@ -0,0 +1,5 @@
+from .base import AuthenticationBase as AuthenticationBase
+
+class Passwordless(AuthenticationBase):
+    def email(self, email: str, send: str = "link", auth_params: dict[str, str] | None = None): ...
+    def sms(self, phone_number: str): ...

auth0-stubs/authentication/pushed_authorization_requests.pyi

@@ -0,0 +1,4 @@
+from .base import AuthenticationBase as AuthenticationBase
+
+class PushedAuthorizationRequests(AuthenticationBase):
+    def pushed_authorization_request(self, response_type: str, redirect_uri: str, **kwargs): ...

auth0-stubs/authentication/revoke_token.pyi

@@ -0,0 +1,4 @@
+from .base import AuthenticationBase as AuthenticationBase
+
+class RevokeToken(AuthenticationBase):
+    def revoke_refresh_token(self, token: str): ...

auth0-stubs/authentication/social.pyi

@@ -0,0 +1,4 @@
+from .base import AuthenticationBase as AuthenticationBase
+
+class Social(AuthenticationBase):
+    def login(self, access_token: str, connection: str, scope: str = "openid"): ...

auth0-stubs/authentication/token_verifier.pyi

@@ -0,0 +1,29 @@
+from _typeshed import Incomplete
+from typing import ClassVar
+
+from auth0.exceptions import TokenValidationError as TokenValidationError
+
+class SignatureVerifier:
+    DISABLE_JWT_CHECKS: ClassVar[dict[str, bool]]
+    def __init__(self, algorithm: str) -> None: ...
+    async def verify_signature(self, token: str) -> dict[str, Incomplete]: ...
+
+class SymmetricSignatureVerifier(SignatureVerifier):
+    def __init__(self, shared_secret: str, algorithm: str = "HS256") -> None: ...
+
+class JwksFetcher:
+    CACHE_TTL: ClassVar[int]
+    def __init__(self, jwks_url: str, cache_ttl: int = ...) -> None: ...
+    def get_key(self, key_id: str): ...
+
+class AsymmetricSignatureVerifier(SignatureVerifier):
+    def __init__(self, jwks_url: str, algorithm: str = "RS256", cache_ttl: int = ...) -> None: ...
+
+class TokenVerifier:
+    iss: Incomplete
+    aud: Incomplete
+    leeway: Incomplete
+    def __init__(self, signature_verifier: SignatureVerifier, issuer: str, audience: str, leeway: int = 0) -> None: ...
+    def verify(
+        self, token: str, nonce: str | None = None, max_age: int | None = None, organization: str | None = None
+    ) -> dict[str, Incomplete]: ...

auth0-stubs/authentication/users.pyi

@@ -0,0 +1,11 @@
+from _typeshed import Incomplete
+
+from auth0.rest import RestClient as RestClient, RestClientOptions as RestClientOptions
+from auth0.types import TimeoutType as TimeoutType
+
+class Users:
+    domain: Incomplete
+    protocol: Incomplete
+    client: Incomplete
+    def __init__(self, domain: str, telemetry: bool = True, timeout: TimeoutType = 5.0, protocol: str = "https") -> None: ...
+    def userinfo(self, access_token: str) -> dict[str, Incomplete]: ...

auth0-stubs/exceptions.pyi

@@ -0,0 +1,14 @@
+from _typeshed import Incomplete
+
+class Auth0Error(Exception):
+    status_code: Incomplete
+    error_code: Incomplete
+    message: Incomplete
+    content: Incomplete
+    def __init__(self, status_code: int, error_code: str, message: str, content: Incomplete | None = None) -> None: ...
+
+class RateLimitError(Auth0Error):
+    reset_at: Incomplete
+    def __init__(self, error_code: str, message: str, reset_at: int) -> None: ...
+
+class TokenValidationError(Exception): ...

auth0-stubs/management/__init__.pyi

@@ -0,0 +1,63 @@
+from .actions import Actions as Actions
+from .attack_protection import AttackProtection as AttackProtection
+from .auth0 import Auth0 as Auth0
+from .blacklists import Blacklists as Blacklists
+from .branding import Branding as Branding
+from .client_credentials import ClientCredentials as ClientCredentials
+from .client_grants import ClientGrants as ClientGrants
+from .clients import Clients as Clients
+from .connections import Connections as Connections
+from .custom_domains import CustomDomains as CustomDomains
+from .device_credentials import DeviceCredentials as DeviceCredentials
+from .email_templates import EmailTemplates as EmailTemplates
+from .emails import Emails as Emails
+from .grants import Grants as Grants
+from .guardian import Guardian as Guardian
+from .hooks import Hooks as Hooks
+from .jobs import Jobs as Jobs
+from .log_streams import LogStreams as LogStreams
+from .logs import Logs as Logs
+from .organizations import Organizations as Organizations
+from .resource_servers import ResourceServers as ResourceServers
+from .roles import Roles as Roles
+from .rules import Rules as Rules
+from .rules_configs import RulesConfigs as RulesConfigs
+from .stats import Stats as Stats
+from .tenants import Tenants as Tenants
+from .tickets import Tickets as Tickets
+from .user_blocks import UserBlocks as UserBlocks
+from .users import Users as Users
+from .users_by_email import UsersByEmail as UsersByEmail
+
+__all__ = (
+    "Auth0",
+    "Actions",
+    "AttackProtection",
+    "Blacklists",
+    "Branding",
+    "ClientCredentials",
+    "ClientGrants",
+    "Clients",
+    "Connections",
+    "CustomDomains",
+    "DeviceCredentials",
+    "EmailTemplates",
+    "Emails",
+    "Grants",
+    "Guardian",
+    "Hooks",
+    "Jobs",
+    "LogStreams",
+    "Logs",
+    "Organizations",
+    "ResourceServers",
+    "Roles",
+    "RulesConfigs",
+    "Rules",
+    "Stats",
+    "Tenants",
+    "Tickets",
+    "UserBlocks",
+    "UsersByEmail",
+    "Users",
+)

auth0-stubs/management/actions.pyi

@@ -0,0 +1,64 @@
+from _typeshed import Incomplete
+
+from ..rest import RestClient as RestClient, RestClientOptions as RestClientOptions
+from ..types import TimeoutType as TimeoutType
+
+class Actions:
+    domain: Incomplete
+    protocol: Incomplete
+    client: Incomplete
+    def __init__(
+        self,
+        domain: str,
+        token: str,
+        telemetry: bool = True,
+        timeout: TimeoutType = 5.0,
+        protocol: str = "https",
+        rest_options: RestClientOptions | None = None,
+    ) -> None: ...
+    def get_actions(
+        self,
+        trigger_id: str | None = None,
+        action_name: str | None = None,
+        deployed: bool | None = None,
+        installed: bool = False,
+        page: int | None = None,
+        per_page: int | None = None,
+    ): ...
+    async def get_actions_async(
+        self,
+        trigger_id: str | None = None,
+        action_name: str | None = None,
+        deployed: bool | None = None,
+        installed: bool = False,
+        page: int | None = None,
+        per_page: int | None = None,
+    ): ...
+    def create_action(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def create_action_async(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    def update_action(self, id: str, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def update_action_async(self, id: str, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    def get_action(self, id: str) -> dict[str, Incomplete]: ...
+    async def get_action_async(self, id: str) -> dict[str, Incomplete]: ...
+    def delete_action(self, id: str, force: bool = False): ...
+    async def delete_action_async(self, id: str, force: bool = False): ...
+    def get_triggers(self) -> dict[str, Incomplete]: ...
+    async def get_triggers_async(self) -> dict[str, Incomplete]: ...
+    def get_execution(self, id: str) -> dict[str, Incomplete]: ...
+    async def get_execution_async(self, id: str) -> dict[str, Incomplete]: ...
+    def get_action_versions(self, id: str, page: int | None = None, per_page: int | None = None) -> dict[str, Incomplete]: ...
+    async def get_action_versions_async(
+        self, id: str, page: int | None = None, per_page: int | None = None
+    ) -> dict[str, Incomplete]: ...
+    def get_trigger_bindings(self, id: str, page: int | None = None, per_page: int | None = None) -> dict[str, Incomplete]: ...
+    async def get_trigger_bindings_async(
+        self, id: str, page: int | None = None, per_page: int | None = None
+    ) -> dict[str, Incomplete]: ...
+    def get_action_version(self, action_id: str, version_id: str) -> dict[str, Incomplete]: ...
+    async def get_action_version_async(self, action_id: str, version_id: str) -> dict[str, Incomplete]: ...
+    def deploy_action(self, id: str) -> dict[str, Incomplete]: ...
+    async def deploy_action_async(self, id: str) -> dict[str, Incomplete]: ...
+    def rollback_action_version(self, action_id: str, version_id: str) -> dict[str, Incomplete]: ...
+    async def rollback_action_version_async(self, action_id: str, version_id: str) -> dict[str, Incomplete]: ...
+    def update_trigger_bindings(self, id: str, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def update_trigger_bindings_async(self, id: str, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...

auth0-stubs/management/async_auth0.pyi

@@ -0,0 +1,15 @@
+from types import TracebackType
+from typing_extensions import Self
+
+from auth0.rest import RestClientOptions as RestClientOptions
+
+from ..asyncify import asyncify as asyncify
+from .auth0 import Auth0 as Auth0
+
+class AsyncAuth0:
+    def __init__(self, domain: str, token: str, rest_options: RestClientOptions | None = None) -> None: ...
+    def set_session(self, session) -> None: ...
+    async def __aenter__(self) -> Self: ...
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...

auth0-stubs/management/attack_protection.pyi

@@ -0,0 +1,30 @@
+from _typeshed import Incomplete
+
+from ..rest import RestClient as RestClient, RestClientOptions as RestClientOptions
+from ..types import TimeoutType as TimeoutType
+
+class AttackProtection:
+    domain: Incomplete
+    protocol: Incomplete
+    client: Incomplete
+    def __init__(
+        self,
+        domain: str,
+        token: str,
+        telemetry: bool = True,
+        timeout: TimeoutType = 5.0,
+        protocol: str = "https",
+        rest_options: RestClientOptions | None = None,
+    ) -> None: ...
+    def get_breached_password_detection(self) -> dict[str, Incomplete]: ...
+    async def get_breached_password_detection_async(self) -> dict[str, Incomplete]: ...
+    def update_breached_password_detection(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def update_breached_password_detection_async(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    def get_brute_force_protection(self) -> dict[str, Incomplete]: ...
+    async def get_brute_force_protection_async(self) -> dict[str, Incomplete]: ...
+    def update_brute_force_protection(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def update_brute_force_protection_async(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    def get_suspicious_ip_throttling(self) -> dict[str, Incomplete]: ...
+    async def get_suspicious_ip_throttling_async(self) -> dict[str, Incomplete]: ...
+    def update_suspicious_ip_throttling(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def update_suspicious_ip_throttling_async(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...

auth0-stubs/management/auth0.pyi

@@ -0,0 +1,67 @@
+from _typeshed import Incomplete
+
+from auth0.rest import RestClientOptions as RestClientOptions
+
+from .actions import Actions as Actions
+from .attack_protection import AttackProtection as AttackProtection
+from .blacklists import Blacklists as Blacklists
+from .branding import Branding as Branding
+from .client_credentials import ClientCredentials as ClientCredentials
+from .client_grants import ClientGrants as ClientGrants
+from .clients import Clients as Clients
+from .connections import Connections as Connections
+from .custom_domains import CustomDomains as CustomDomains
+from .device_credentials import DeviceCredentials as DeviceCredentials
+from .email_templates import EmailTemplates as EmailTemplates
+from .emails import Emails as Emails
+from .grants import Grants as Grants
+from .guardian import Guardian as Guardian
+from .hooks import Hooks as Hooks
+from .jobs import Jobs as Jobs
+from .log_streams import LogStreams as LogStreams
+from .logs import Logs as Logs
+from .organizations import Organizations as Organizations
+from .prompts import Prompts as Prompts
+from .resource_servers import ResourceServers as ResourceServers
+from .roles import Roles as Roles
+from .rules import Rules as Rules
+from .rules_configs import RulesConfigs as RulesConfigs
+from .stats import Stats as Stats
+from .tenants import Tenants as Tenants
+from .tickets import Tickets as Tickets
+from .user_blocks import UserBlocks as UserBlocks
+from .users import Users as Users
+from .users_by_email import UsersByEmail as UsersByEmail
+
+class Auth0:
+    actions: Incomplete
+    attack_protection: Incomplete
+    blacklists: Incomplete
+    branding: Incomplete
+    client_credentials: Incomplete
+    client_grants: Incomplete
+    clients: Incomplete
+    connections: Incomplete
+    custom_domains: Incomplete
+    device_credentials: Incomplete
+    email_templates: Incomplete
+    emails: Incomplete
+    grants: Incomplete
+    guardian: Incomplete
+    hooks: Incomplete
+    jobs: Incomplete
+    log_streams: Incomplete
+    logs: Incomplete
+    organizations: Incomplete
+    prompts: Incomplete
+    resource_servers: Incomplete
+    roles: Incomplete
+    rules_configs: Incomplete
+    rules: Incomplete
+    stats: Incomplete
+    tenants: Incomplete
+    tickets: Incomplete
+    user_blocks: Incomplete
+    users_by_email: Incomplete
+    users: Incomplete
+    def __init__(self, domain: str, token: str, rest_options: RestClientOptions | None = None) -> None: ...

auth0-stubs/management/blacklists.pyi

@@ -0,0 +1,21 @@
+from _typeshed import Incomplete
+
+from ..rest import RestClient as RestClient, RestClientOptions as RestClientOptions
+from ..types import TimeoutType as TimeoutType
+
+class Blacklists:
+    url: Incomplete
+    client: Incomplete
+    def __init__(
+        self,
+        domain: str,
+        token: str,
+        telemetry: bool = True,
+        timeout: TimeoutType = 5.0,
+        protocol: str = "https",
+        rest_options: RestClientOptions | None = None,
+    ) -> None: ...
+    def get(self, aud: str | None = None) -> list[dict[str, str]]: ...
+    async def get_async(self, aud: str | None = None) -> list[dict[str, str]]: ...
+    def create(self, jti: str, aud: str | None = None) -> dict[str, str]: ...
+    async def create_async(self, jti: str, aud: str | None = None) -> dict[str, str]: ...

auth0-stubs/management/branding.pyi

@@ -0,0 +1,38 @@
+from _typeshed import Incomplete
+
+from ..rest import RestClient as RestClient, RestClientOptions as RestClientOptions
+from ..types import TimeoutType as TimeoutType
+
+class Branding:
+    domain: Incomplete
+    protocol: Incomplete
+    client: Incomplete
+    def __init__(
+        self,
+        domain: str,
+        token: str,
+        telemetry: bool = True,
+        timeout: TimeoutType = 5.0,
+        protocol: str = "https",
+        rest_options: RestClientOptions | None = None,
+    ) -> None: ...
+    def get(self) -> dict[str, Incomplete]: ...
+    async def get_async(self) -> dict[str, Incomplete]: ...
+    def update(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def update_async(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    def get_template_universal_login(self) -> dict[str, Incomplete]: ...
+    async def get_template_universal_login_async(self) -> dict[str, Incomplete]: ...
+    def delete_template_universal_login(self): ...
+    async def delete_template_universal_login_async(self): ...
+    def update_template_universal_login(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def update_template_universal_login_async(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    def get_default_branding_theme(self) -> dict[str, Incomplete]: ...
+    async def get_default_branding_theme_async(self) -> dict[str, Incomplete]: ...
+    def get_branding_theme(self, theme_id: str) -> dict[str, Incomplete]: ...
+    async def get_branding_theme_async(self, theme_id: str) -> dict[str, Incomplete]: ...
+    def delete_branding_theme(self, theme_id: str): ...
+    async def delete_branding_theme_async(self, theme_id: str): ...
+    def update_branding_theme(self, theme_id: str, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def update_branding_theme_async(self, theme_id: str, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    def create_branding_theme(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def create_branding_theme_async(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...

auth0-stubs/management/client_credentials.pyi

@@ -0,0 +1,26 @@
+from _typeshed import Incomplete
+
+from ..rest import RestClient as RestClient, RestClientOptions as RestClientOptions
+from ..types import TimeoutType as TimeoutType
+
+class ClientCredentials:
+    domain: Incomplete
+    protocol: Incomplete
+    client: Incomplete
+    def __init__(
+        self,
+        domain: str,
+        token: str,
+        telemetry: bool = True,
+        timeout: TimeoutType = 5.0,
+        protocol: str = "https",
+        rest_options: RestClientOptions | None = None,
+    ) -> None: ...
+    def all(self, client_id: str) -> list[dict[str, Incomplete]]: ...
+    async def all_async(self, client_id: str) -> list[dict[str, Incomplete]]: ...
+    def get(self, client_id: str, id: str) -> dict[str, Incomplete]: ...
+    async def get_async(self, client_id: str, id: str) -> dict[str, Incomplete]: ...
+    def create(self, client_id: str, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def create_async(self, client_id: str, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    def delete(self, client_id: str, id: str) -> dict[str, Incomplete]: ...
+    async def delete_async(self, client_id: str, id: str) -> dict[str, Incomplete]: ...

auth0-stubs/management/client_grants.pyi

@@ -0,0 +1,60 @@
+from _typeshed import Incomplete
+
+from ..rest import RestClient as RestClient, RestClientOptions as RestClientOptions
+from ..types import TimeoutType as TimeoutType
+
+class ClientGrants:
+    domain: Incomplete
+    protocol: Incomplete
+    client: Incomplete
+    def __init__(
+        self,
+        domain: str,
+        token: str,
+        telemetry: bool = True,
+        timeout: TimeoutType = 5.0,
+        protocol: str = "https",
+        rest_options: RestClientOptions | None = None,
+    ) -> None: ...
+    def all(
+        self,
+        audience: str | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+        include_totals: bool = False,
+        client_id: str | None = None,
+        allow_any_organization: bool | None = None,
+    ) -> dict[str, Incomplete]: ...
+    async def all_async(
+        self,
+        audience: str | None = None,
+        page: int | None = None,
+        per_page: int | None = None,
+        include_totals: bool = False,
+        client_id: str | None = None,
+        allow_any_organization: bool | None = None,
+    ) -> dict[str, Incomplete]: ...
+    def create(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def create_async(self, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    def delete(self, id: str): ...
+    async def delete_async(self, id: str): ...
+    def update(self, id: str, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    async def update_async(self, id: str, body: dict[str, Incomplete]) -> dict[str, Incomplete]: ...
+    def get_organizations(
+        self,
+        id: str,
+        page: int | None = None,
+        per_page: int | None = None,
+        include_totals: bool = False,
+        from_param: str | None = None,
+        take: int | None = None,
+    ) -> dict[str, Incomplete]: ...
+    async def get_organizations_async(
+        self,
+        id: str,
+        page: int | None = None,
+        per_page: int | None = None,
+        include_totals: bool = False,
+        from_param: str | None = None,
+        take: int | None = None,
+    ) -> dict[str, Incomplete]: ...