internetdata 2.7.5__tar.gz → 2.9.0__tar.gz

{internetdata-2.7.5 → internetdata-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: internetdata
-Version: 2.7.5
+Version: 2.9.0
 Summary: Official Python client library for the InternetData API. Download and verify licensed IP datasets.
 Project-URL: Homepage, https://internetdata.io
 Project-URL: Documentation, https://docs.internetdata.io
@@ -223,6 +223,20 @@ tokens = signin.oauth.exchange_authorization_code("your-client-id", code, pkce.v
 
 Check that `state` came back as you sent it before you exchange `code`, which works once. The client ID can also be the https URL of a client metadata document your app serves, and such an app is never handed a key, so `tokens.apikey` stays `None`.
 
+### Register a client
+
+An app with no client ID, and no client metadata document to use as one, registers itself and signs in with the `client_id` it gets back:
+
+```python
+client = InternetData()
+registration = client.oauth.register(
+    ["http://127.0.0.1:8765/callback"], client_name="Your App"
+)
+# registration.client_id is the client ID for authorization_url and exchange_authorization_code.
+```
+
+Each redirect URI must be https on a public host name, or http on a loopback address, which then matches any port. Nothing is kept until a person approves the client, so an app with no client ID saved can simply register again.
+
 ## Other Libraries
 
 There are official InternetData client libraries available for many languages including PHP, Python, Go, Java, and Ruby. See our GitHub at https://github.com/internetdata for more.

{internetdata-2.7.5 → internetdata-2.9.0}/README.md

@@ -189,6 +189,20 @@ tokens = signin.oauth.exchange_authorization_code("your-client-id", code, pkce.v
 
 Check that `state` came back as you sent it before you exchange `code`, which works once. The client ID can also be the https URL of a client metadata document your app serves, and such an app is never handed a key, so `tokens.apikey` stays `None`.
 
+### Register a client
+
+An app with no client ID, and no client metadata document to use as one, registers itself and signs in with the `client_id` it gets back:
+
+```python
+client = InternetData()
+registration = client.oauth.register(
+    ["http://127.0.0.1:8765/callback"], client_name="Your App"
+)
+# registration.client_id is the client ID for authorization_url and exchange_authorization_code.
+```
+
+Each redirect URI must be https on a public host name, or http on a loopback address, which then matches any port. Nothing is kept until a person approves the client, so an app with no client ID saved can simply register again.
+
 ## Other Libraries
 
 There are official InternetData client libraries available for many languages including PHP, Python, Go, Java, and Ruby. See our GitHub at https://github.com/internetdata for more.

{internetdata-2.7.5 → internetdata-2.9.0}/spec/openapi.yaml

@@ -12,7 +12,7 @@ info:
     email: support@internetdata.io
     url: https://internetdata.io
   termsOfService: https://internetdata.io/terms
-  version: 2026.10.15
+  version: 2026.10.16
 servers:
   - url: https://internetdata.io
 tags:
@@ -653,6 +653,56 @@ paths:
             application/json:
               schema:
                 $ref: '#/components/schemas/OauthError'
+  /oauth/register:
+    post:
+      operationId: oauthRegister
+      tags:
+        - Authorization
+      summary: Register
+      description: |
+        RFC 7591 dynamic client registration, for a client that cannot use a
+        Client ID Metadata Document. Post your client's metadata as JSON, then
+        use the `client_id` in the answer at `/oauth/authorize` and
+        `/oauth/token`. Nothing is kept until a person approves your client, so
+        registering again costs nothing and leaves nothing to clean up.
+
+        Each redirect URI must be https on a public host name, or http on a
+        loopback address (`127.0.0.1`, `[::1]`, `localhost`), which then
+        matches on any port. A custom URI scheme is refused: use a loopback
+        redirect instead. So is a host on one of our own domains.
+
+        `client_name` is shown to the person as your client's own claim, with
+        where its redirect goes beside it. A name that renders blank, or mixes
+        Latin letters with Cyrillic or Greek ones, is shown as an unnamed
+        application.
+
+        The client is public whatever you ask for: `token_endpoint_auth_method`
+        comes back `none`, there is no client secret, and every authorization
+        proves itself with PKCE. It may be granted `apikeys.use` at most.
+      security: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ClientRegistrationRequest'
+      responses:
+        '201':
+          description: The client, as registered.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ClientRegistration'
+        '400':
+          description: |
+            `invalid_redirect_uri` names the redirect URI refused and why, and
+            `invalid_client_metadata` anything else, such as a client that
+            does not use the authorization code flow. `slow_down` means this
+            address registered too many clients in the last minute.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/OauthError'
   /oauth/authorize:
     get:
       operationId: oauthAuthorize
@@ -669,13 +719,18 @@ paths:
         with `token_endpoint_auth_method` `none` and your `redirect_uris`. An
         https redirect URI must be on the same origin as the `client_id`; a
         loopback one (`http://127.0.0.1`, `http://[::1]`, `http://localhost`)
-        matches on any port. Such a client is granted `apikeys.use` at most.
+        matches on any port. Such a client is granted `apikeys.use` at most. A
+        client registered at `/oauth/register` uses the `client_id` it was
+        given and one of the `redirect_uris` it registered.
 
         An unknown `client_id` or an unregistered `redirect_uri` is shown to the
-        USER and never redirected, because sending an error to an address we
-        have not verified belongs to you is how an open redirector works.
-        Everything else comes back to your `redirect_uri` with `error`, your
-        `state`, and `iss`.
+        person and never redirected, because sending an error to an address we
+        have not verified belongs to you is how an open redirector works. Any
+        other error in the request is shown to the person too: anyone can make a
+        client, so its `redirect_uri` is verified only as its own (RFC 9700
+        section 4.11.2). Only the person's answer comes back to your
+        `redirect_uri`: a `code`, or `error` `access_denied`, each with your
+        `state` and `iss`.
       security: []
       parameters:
         - name: client_id
@@ -731,9 +786,9 @@ paths:
             given that server.
       responses:
         '302':
-          description: A redirect to the consent screen, or back to your redirect_uri with an error.
+          description: A redirect to the consent screen.
         '400':
-          description: Shown to the user. An unverified redirect target is never sent an error.
+          description: Shown to the person. No error in the request is sent to your redirect_uri.
         '429':
           description: Shown to the user. Too many authorizations from one address.
   /oauth/token:
@@ -1485,6 +1540,9 @@ components:
         client_id_metadata_document_supported:
           type: boolean
           description: Any client may sign in with an https `client_id` serving its own metadata.
+        registration_endpoint:
+          type: string
+          description: RFC 7591 dynamic client registration, for a client that cannot serve its own metadata.
         token_endpoint_auth_methods_supported:
           type: array
           items:
@@ -1600,7 +1658,8 @@ components:
           type: string
           description: |
             Not part of OAuth, and only for our own clients: a client that signed
-            in with a Client ID Metadata Document never receives a key. The API
+            in with a Client ID Metadata Document or registered itself never
+            receives a key. The API
             key itself, so a device ends up holding an ordinary key. Returned by
             the device code and authorization code grants only, never by a
             refresh, and only alongside
@@ -1611,6 +1670,70 @@ components:
         - access_token
         - token_type
         - expires_in
+    ClientRegistrationRequest:
+      type: object
+      properties:
+        redirect_uris:
+          type: array
+          items:
+            type: string
+          description: One to ten, each matched exactly, apart from a loopback one's port.
+        client_name:
+          type: string
+          description: >-
+            Shown to the person as your client's own claim, marked unverified, beside where its
+            redirect goes.
+        grant_types:
+          type: array
+          items:
+            type: string
+          description: Must include `authorization_code` when given.
+        response_types:
+          type: array
+          items:
+            type: string
+          description: Must include `code` when given.
+        token_endpoint_auth_method:
+          type: string
+          description: Read as `none`, whatever is sent.
+      required:
+        - redirect_uris
+    ClientRegistration:
+      type: object
+      properties:
+        client_id:
+          type: string
+        client_id_issued_at:
+          type: integer
+          description: Unix seconds.
+        client_name:
+          type: string
+          description: As the person will see it.
+        redirect_uris:
+          type: array
+          items:
+            type: string
+        grant_types:
+          type: array
+          items:
+            type: string
+          description: '`authorization_code` and `refresh_token`.'
+        response_types:
+          type: array
+          items:
+            type: string
+        token_endpoint_auth_method:
+          type: string
+          description: Always `none`.
+        scope:
+          type: string
+          description: 'The most this client may be granted: `apikeys.use`.'
+      required:
+        - client_id
+        - client_id_issued_at
+        - client_name
+        - redirect_uris
+        - token_endpoint_auth_method
     RevokeRequest:
       type: object
       properties:

{internetdata-2.7.5 → internetdata-2.9.0}/src/internetdata/__init__.py

@@ -24,6 +24,7 @@ from .models import (
     DATABASE_FORMATS,
     LICENSE_TYPES,
     STANDINGS,
+    ClientRegistration,
     Database,
     DatabaseMetadata,
     DatabaseVersion,
@@ -39,7 +40,7 @@ from .models import (
     TokenResponse,
 )
 
-__version__ = "2.7.5"
+__version__ = "2.9.0"
 
 __all__ = [
     "DATABASE_FORMATS",
@@ -49,6 +50,7 @@ __all__ = [
     "AsyncDatabaseApi",
     "AsyncInternetData",
     "AsyncOauthApi",
+    "ClientRegistration",
     "Database",
     "DatabaseApi",
     "DatabaseMetadata",

{internetdata-2.7.5 → internetdata-2.9.0}/src/internetdata/_core.py

@@ -14,7 +14,7 @@ import os
 import secrets
 import threading
 import time
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Iterator, Sequence
 from pathlib import Path
 from types import ModuleType
 from typing import IO, Any, TypeVar, cast
@@ -36,6 +36,7 @@ OAUTH_DEVICE_AUTHORIZATION_PATH = "/oauth/device_authorization"
 OAUTH_TOKEN_PATH = "/oauth/token"
 OAUTH_REVOKE_PATH = "/oauth/revoke"
 OAUTH_AUTHORIZE_PATH = "/oauth/authorize"
+OAUTH_REGISTER_PATH = "/oauth/register"
 DEVICE_CODE_GRANT = "urn:ietf:params:oauth:grant-type:device_code"
 
 # One chunk of a transfer, and therefore the ceiling on what a download of any size
@@ -348,10 +349,13 @@ def oauth_request(
     path: str,
     form: dict[str, str] | None,
     bound: float | None,
+    body: dict[str, Any] | None = None,
 ) -> httpx.Response:
-    """One attempt at an OAuth endpoint, carrying no credential, its failure raised."""
+    """One attempt at an OAuth endpoint, carrying no credential, its failure raised. `body`
+    goes as JSON, for `register`; every other one sends a form or nothing."""
     http = client.get_httpx_client()
-    return oauth_checked(exchange(http, _oauth_build(http, method, path, form, bound), bound))
+    req = _oauth_build(http, method, path, form, bound, body)
+    return oauth_checked(exchange(http, req, bound))
 
 
 async def oauth_request_async(
@@ -360,13 +364,39 @@ async def oauth_request_async(
     path: str,
     form: dict[str, str] | None,
     bound: float | None,
+    body: dict[str, Any] | None = None,
 ) -> httpx.Response:
     """`oauth_request`, awaited."""
     http = client.get_async_httpx_client()
-    req = _oauth_build(http, method, path, form, bound)
+    req = _oauth_build(http, method, path, form, bound, body)
     return oauth_checked(await exchange_async(http, req, bound))
 
 
+def registration_body(redirect_uris: Sequence[str], client_name: str | None) -> dict[str, Any]:
+    """`register`'s JSON body: the redirect URIs in the order given, then `client_name`
+    unless it is None or empty. No URI at all, an empty one, or one with no UTF-8 (a lone
+    surrogate) is refused before anything is sent."""
+    if isinstance(redirect_uris, str) or not redirect_uris:
+        raise ValueError(f"redirect_uris must list at least one URI, not {redirect_uris!r}")
+    uris = list(redirect_uris)
+    for i, uri in enumerate(uris):
+        _check_text(f"redirect_uris[{i}]", uri)
+    body: dict[str, Any] = {"redirect_uris": uris}
+    if client_name:
+        _check_text("client_name", client_name)
+        body["client_name"] = client_name
+    return body
+
+
+def _check_text(name: str, value: Any) -> None:
+    if not isinstance(value, str) or value == "":
+        raise ValueError(f"{name} must be a non-empty string, not {value!r}")
+    try:
+        value.encode("utf-8")
+    except UnicodeEncodeError as exc:
+        raise ValueError(f"{name} has no UTF-8 to send: {value!r}") from exc
+
+
 def authorization_url(
     base_url: str,
     client_id: str,
@@ -571,8 +601,9 @@ def _oauth_build(
     path: str,
     form: dict[str, str] | None,
     bound: float | None,
+    body: dict[str, Any] | None = None,
 ) -> httpx.Request:
-    req = http.build_request(method, path, data=form, timeout=httpx.Timeout(bound))
+    req = http.build_request(method, path, data=form, json=body, timeout=httpx.Timeout(bound))
     req.headers.pop("authorization", None)
     return req
 

{internetdata-2.7.5 → internetdata-2.9.0}/src/internetdata/_generated/api/authorization/oauth_authorize.py

@@ -105,13 +105,18 @@ def sync_detailed(
     with `token_endpoint_auth_method` `none` and your `redirect_uris`. An
     https redirect URI must be on the same origin as the `client_id`; a
     loopback one (`http://127.0.0.1`, `http://[::1]`, `http://localhost`)
-    matches on any port. Such a client is granted `apikeys.use` at most.
+    matches on any port. Such a client is granted `apikeys.use` at most. A
+    client registered at `/oauth/register` uses the `client_id` it was
+    given and one of the `redirect_uris` it registered.
 
     An unknown `client_id` or an unregistered `redirect_uri` is shown to the
-    USER and never redirected, because sending an error to an address we
-    have not verified belongs to you is how an open redirector works.
-    Everything else comes back to your `redirect_uri` with `error`, your
-    `state`, and `iss`.
+    person and never redirected, because sending an error to an address we
+    have not verified belongs to you is how an open redirector works. Any
+    other error in the request is shown to the person too: anyone can make a
+    client, so its `redirect_uri` is verified only as its own (RFC 9700
+    section 4.11.2). Only the person's answer comes back to your
+    `redirect_uri`: a `code`, or `error` `access_denied`, each with your
+    `state` and `iss`.
 
     Args:
         client_id (str):
@@ -172,13 +177,18 @@ async def asyncio_detailed(
     with `token_endpoint_auth_method` `none` and your `redirect_uris`. An
     https redirect URI must be on the same origin as the `client_id`; a
     loopback one (`http://127.0.0.1`, `http://[::1]`, `http://localhost`)
-    matches on any port. Such a client is granted `apikeys.use` at most.
+    matches on any port. Such a client is granted `apikeys.use` at most. A
+    client registered at `/oauth/register` uses the `client_id` it was
+    given and one of the `redirect_uris` it registered.
 
     An unknown `client_id` or an unregistered `redirect_uri` is shown to the
-    USER and never redirected, because sending an error to an address we
-    have not verified belongs to you is how an open redirector works.
-    Everything else comes back to your `redirect_uri` with `error`, your
-    `state`, and `iss`.
+    person and never redirected, because sending an error to an address we
+    have not verified belongs to you is how an open redirector works. Any
+    other error in the request is shown to the person too: anyone can make a
+    client, so its `redirect_uri` is verified only as its own (RFC 9700
+    section 4.11.2). Only the person's answer comes back to your
+    `redirect_uri`: a `code`, or `error` `access_denied`, each with your
+    `state` and `iss`.
 
     Args:
         client_id (str):

internetdata-2.9.0/src/internetdata/_generated/api/authorization/oauth_register.py

@@ -0,0 +1,246 @@
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.client_registration import ClientRegistration
+from ...models.client_registration_request import ClientRegistrationRequest
+from ...models.oauth_error import OauthError
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: ClientRegistrationRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/oauth/register",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> ClientRegistration | OauthError | None:
+    if response.status_code == 201:
+        response_201 = ClientRegistration.from_dict(response.json())
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = OauthError.from_dict(response.json())
+
+        return response_400
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[ClientRegistration | OauthError]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: ClientRegistrationRequest,
+) -> Response[ClientRegistration | OauthError]:
+    """Register
+
+     RFC 7591 dynamic client registration, for a client that cannot use a
+    Client ID Metadata Document. Post your client's metadata as JSON, then
+    use the `client_id` in the answer at `/oauth/authorize` and
+    `/oauth/token`. Nothing is kept until a person approves your client, so
+    registering again costs nothing and leaves nothing to clean up.
+
+    Each redirect URI must be https on a public host name, or http on a
+    loopback address (`127.0.0.1`, `[::1]`, `localhost`), which then
+    matches on any port. A custom URI scheme is refused: use a loopback
+    redirect instead. So is a host on one of our own domains.
+
+    `client_name` is shown to the person as your client's own claim, with
+    where its redirect goes beside it. A name that renders blank, or mixes
+    Latin letters with Cyrillic or Greek ones, is shown as an unnamed
+    application.
+
+    The client is public whatever you ask for: `token_endpoint_auth_method`
+    comes back `none`, there is no client secret, and every authorization
+    proves itself with PKCE. It may be granted `apikeys.use` at most.
+
+    Args:
+        body (ClientRegistrationRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ClientRegistration | OauthError]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    body: ClientRegistrationRequest,
+) -> ClientRegistration | OauthError | None:
+    """Register
+
+     RFC 7591 dynamic client registration, for a client that cannot use a
+    Client ID Metadata Document. Post your client's metadata as JSON, then
+    use the `client_id` in the answer at `/oauth/authorize` and
+    `/oauth/token`. Nothing is kept until a person approves your client, so
+    registering again costs nothing and leaves nothing to clean up.
+
+    Each redirect URI must be https on a public host name, or http on a
+    loopback address (`127.0.0.1`, `[::1]`, `localhost`), which then
+    matches on any port. A custom URI scheme is refused: use a loopback
+    redirect instead. So is a host on one of our own domains.
+
+    `client_name` is shown to the person as your client's own claim, with
+    where its redirect goes beside it. A name that renders blank, or mixes
+    Latin letters with Cyrillic or Greek ones, is shown as an unnamed
+    application.
+
+    The client is public whatever you ask for: `token_endpoint_auth_method`
+    comes back `none`, there is no client secret, and every authorization
+    proves itself with PKCE. It may be granted `apikeys.use` at most.
+
+    Args:
+        body (ClientRegistrationRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ClientRegistration | OauthError
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: ClientRegistrationRequest,
+) -> Response[ClientRegistration | OauthError]:
+    """Register
+
+     RFC 7591 dynamic client registration, for a client that cannot use a
+    Client ID Metadata Document. Post your client's metadata as JSON, then
+    use the `client_id` in the answer at `/oauth/authorize` and
+    `/oauth/token`. Nothing is kept until a person approves your client, so
+    registering again costs nothing and leaves nothing to clean up.
+
+    Each redirect URI must be https on a public host name, or http on a
+    loopback address (`127.0.0.1`, `[::1]`, `localhost`), which then
+    matches on any port. A custom URI scheme is refused: use a loopback
+    redirect instead. So is a host on one of our own domains.
+
+    `client_name` is shown to the person as your client's own claim, with
+    where its redirect goes beside it. A name that renders blank, or mixes
+    Latin letters with Cyrillic or Greek ones, is shown as an unnamed
+    application.
+
+    The client is public whatever you ask for: `token_endpoint_auth_method`
+    comes back `none`, there is no client secret, and every authorization
+    proves itself with PKCE. It may be granted `apikeys.use` at most.
+
+    Args:
+        body (ClientRegistrationRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ClientRegistration | OauthError]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    body: ClientRegistrationRequest,
+) -> ClientRegistration | OauthError | None:
+    """Register
+
+     RFC 7591 dynamic client registration, for a client that cannot use a
+    Client ID Metadata Document. Post your client's metadata as JSON, then
+    use the `client_id` in the answer at `/oauth/authorize` and
+    `/oauth/token`. Nothing is kept until a person approves your client, so
+    registering again costs nothing and leaves nothing to clean up.
+
+    Each redirect URI must be https on a public host name, or http on a
+    loopback address (`127.0.0.1`, `[::1]`, `localhost`), which then
+    matches on any port. A custom URI scheme is refused: use a loopback
+    redirect instead. So is a host on one of our own domains.
+
+    `client_name` is shown to the person as your client's own claim, with
+    where its redirect goes beside it. A name that renders blank, or mixes
+    Latin letters with Cyrillic or Greek ones, is shown as an unnamed
+    application.
+
+    The client is public whatever you ask for: `token_endpoint_auth_method`
+    comes back `none`, there is no client secret, and every authorization
+    proves itself with PKCE. It may be granted `apikeys.use` at most.
+
+    Args:
+        body (ClientRegistrationRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ClientRegistration | OauthError
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

{internetdata-2.7.5 → internetdata-2.9.0}/src/internetdata/_generated/models/__init__.py

@@ -10,6 +10,8 @@ from .account_revealed_apikey import AccountRevealedApikey
 from .account_user import AccountUser
 from .apikey_detail import ApikeyDetail
 from .apikey_list import ApikeyList
+from .client_registration import ClientRegistration
+from .client_registration_request import ClientRegistrationRequest
 from .database import Database
 from .database_checksum_v2_response_200 import DatabaseChecksumV2Response200
 from .database_format import DatabaseFormat
@@ -56,6 +58,8 @@ __all__ = (
     "AccountUser",
     "ApikeyDetail",
     "ApikeyList",
+    "ClientRegistration",
+    "ClientRegistrationRequest",
     "Database",
     "DatabaseChecksumV2Response200",
     "DatabaseFormat",