viio-sync-api-sdk 0.1.0__tar.gz

viio_sync_api_sdk-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.venv/
+__pycache__/
+dist/

viio_sync_api_sdk-0.1.0/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.1.0 (2026-07-31)
+
+
+### Features
+
+* **sync-api:** add Python SDK ([#2313](https://github.com/viio-io/integration-domain/issues/2313)) ([dbbfcf5](https://github.com/viio-io/integration-domain/commit/dbbfcf585dc9d99f71fba6e1ef1d3c4e5f57f9f5))
+
+## Changelog

viio_sync_api_sdk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Viio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

viio_sync_api_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: viio-sync-api-sdk
+Version: 0.1.0
+Summary: Async Python SDK for the Viio Sync API
+Project-URL: Documentation, https://developers.viio.io/sync-api
+Project-URL: Changelog, https://developers.viio.io/sync-api
+Author: Viio
+License-Expression: MIT
+License-File: LICENSE
+Keywords: grpc,sdk,sync,viio
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: grpcio<2,>=1.83
+Requires-Dist: protobuf<8,>=7.35.1
+Description-Content-Type: text/markdown
+
+# Viio Sync API SDK for Python
+
+`viio-sync-api-sdk` contains the generated `viio.sync.v1` protobuf contract and an AsyncIO client for authentication and
+explicit sync-batch lifecycle management.
+
+## Install
+
+```shell
+python -m pip install viio-sync-api-sdk
+```
+
+Python 3.11 and later are supported without an artificial upper minor-version cap. CI validates the minimum version and
+the latest stable Python release, so the upper tested version advances automatically.
+
+## Send a batch
+
+```python
+from viio_sync_api import SyncApiAuthentication, SyncApiClient, SyncApiClientOptions
+from viio_sync_api.v1 import Account, AccountRecords, GenericAccountDetails, SyncRecordsRequest
+
+
+async def sync_accounts() -> None:
+    options = SyncApiClientOptions(
+        endpoint="https://sync.example.com",
+        authentication=SyncApiAuthentication.api_key("your-api-key"),
+    )
+
+    async with SyncApiClient(options) as client:
+        batch = await client.start_batch("installation-id")
+        try:
+            await batch.write(
+                SyncRecordsRequest(
+                    accounts=AccountRecords(
+                        records=[
+                            Account(
+                                generic=GenericAccountDetails(
+                                    id="account-1",
+                                    email="person@example.com",
+                                )
+                            )
+                        ]
+                    )
+                )
+            )
+            await batch.complete()
+        except BaseException:
+            await batch.abort()
+            raise
+```
+
+Each write accepts exactly one typed records wrapper. A present empty wrapper represents an intentional empty snapshot:
+
+```python
+await batch.write(SyncRecordsRequest(accounts=AccountRecords()))
+```
+
+`SyncApiBatchAlreadyInProgressError` distinguishes an existing sync. Protocol failures raise
+`SyncApiProtocolError`. Native `grpc.aio.AioRpcError`, cancellation, and timeout errors remain available for retry
+decisions.
+
+The authenticated generated stub is available as `client.grpc_client`. Calls through it bypass batch validation.
+
+`max_receive_message_size` caps individual responses received by this client, while `max_send_message_size` caps
+individual requests it sends. The receive limit defaults to 16 MiB to match the .NET SDK; setting either value to
+`None` leaves that direction at gRPC's default.
+
+## AWS Lambda
+
+The [complete Lambda handler](https://github.com/viio-io/integration-domain/blob/main/sdk/python/examples/aws_lambda.py)
+acquires an application token from Microsoft Entra ID, pages through Microsoft Graph users, maps each user to
+`MicrosoftEmployeeDetails`, writes a complete employee snapshot, and completes or aborts the Sync API batch. The
+[AWS SAM template](https://github.com/viio-io/integration-domain/blob/main/sdk/python/examples/template.yaml) configures
+Amazon EventBridge Scheduler to invoke it every night with `cron(0 2 * * ? *)`.
+
+Grant the Entra application the Microsoft Graph `User.Read.All` application permission and supply these Lambda
+environment variables from your secret-management system:
+
+- `MICROSOFT_TENANT_ID`
+- `MICROSOFT_CLIENT_ID`
+- `MICROSOFT_CLIENT_SECRET`
+- `VIIO_SYNC_API_ENDPOINT`
+- `VIIO_SYNC_API_KEY`
+- `VIIO_DIRECT_INTEGRATION_INSTALLATION_ID`
+
+The example creates and closes the client inside each invocation's event loop. This avoids retaining a gRPC AsyncIO
+channel across event loops when Lambda reuses a warm execution environment.
+
+`grpcio` contains native code. When creating a Lambda ZIP or layer on another operating system, ask pip for the
+matching Linux wheel:
+
+```shell
+# x86_64
+python -m pip install \
+  --platform manylinux2014_x86_64 \
+  --implementation cp \
+  --python-version 3.11 \
+  --only-binary=:all: \
+  --target package \
+  viio-sync-api-sdk
+
+# arm64
+python -m pip install \
+  --platform manylinux2014_aarch64 \
+  --implementation cp \
+  --python-version 3.11 \
+  --only-binary=:all: \
+  --target package \
+  viio-sync-api-sdk
+```
+
+Replace `3.11` with the Python version of the target Lambda runtime. The same package can be installed normally in AWS
+Lambda Python container images. Full API documentation is available at <https://developers.viio.io/sync-api>.
+
+## Authentication and transport security
+
+External integrations use API keys. Viio-managed callers can supply an asynchronous bearer-token provider.
+
+Sync API endpoints must use HTTPS. HTTP is accepted only for loopback endpoints during development. SDK exception
+messages and representations do not include keys or bearer tokens.
+
+## License
+
+MIT

viio_sync_api_sdk-0.1.0/README.md

@@ -0,0 +1,123 @@
+# Viio Sync API SDK for Python
+
+`viio-sync-api-sdk` contains the generated `viio.sync.v1` protobuf contract and an AsyncIO client for authentication and
+explicit sync-batch lifecycle management.
+
+## Install
+
+```shell
+python -m pip install viio-sync-api-sdk
+```
+
+Python 3.11 and later are supported without an artificial upper minor-version cap. CI validates the minimum version and
+the latest stable Python release, so the upper tested version advances automatically.
+
+## Send a batch
+
+```python
+from viio_sync_api import SyncApiAuthentication, SyncApiClient, SyncApiClientOptions
+from viio_sync_api.v1 import Account, AccountRecords, GenericAccountDetails, SyncRecordsRequest
+
+
+async def sync_accounts() -> None:
+    options = SyncApiClientOptions(
+        endpoint="https://sync.example.com",
+        authentication=SyncApiAuthentication.api_key("your-api-key"),
+    )
+
+    async with SyncApiClient(options) as client:
+        batch = await client.start_batch("installation-id")
+        try:
+            await batch.write(
+                SyncRecordsRequest(
+                    accounts=AccountRecords(
+                        records=[
+                            Account(
+                                generic=GenericAccountDetails(
+                                    id="account-1",
+                                    email="person@example.com",
+                                )
+                            )
+                        ]
+                    )
+                )
+            )
+            await batch.complete()
+        except BaseException:
+            await batch.abort()
+            raise
+```
+
+Each write accepts exactly one typed records wrapper. A present empty wrapper represents an intentional empty snapshot:
+
+```python
+await batch.write(SyncRecordsRequest(accounts=AccountRecords()))
+```
+
+`SyncApiBatchAlreadyInProgressError` distinguishes an existing sync. Protocol failures raise
+`SyncApiProtocolError`. Native `grpc.aio.AioRpcError`, cancellation, and timeout errors remain available for retry
+decisions.
+
+The authenticated generated stub is available as `client.grpc_client`. Calls through it bypass batch validation.
+
+`max_receive_message_size` caps individual responses received by this client, while `max_send_message_size` caps
+individual requests it sends. The receive limit defaults to 16 MiB to match the .NET SDK; setting either value to
+`None` leaves that direction at gRPC's default.
+
+## AWS Lambda
+
+The [complete Lambda handler](https://github.com/viio-io/integration-domain/blob/main/sdk/python/examples/aws_lambda.py)
+acquires an application token from Microsoft Entra ID, pages through Microsoft Graph users, maps each user to
+`MicrosoftEmployeeDetails`, writes a complete employee snapshot, and completes or aborts the Sync API batch. The
+[AWS SAM template](https://github.com/viio-io/integration-domain/blob/main/sdk/python/examples/template.yaml) configures
+Amazon EventBridge Scheduler to invoke it every night with `cron(0 2 * * ? *)`.
+
+Grant the Entra application the Microsoft Graph `User.Read.All` application permission and supply these Lambda
+environment variables from your secret-management system:
+
+- `MICROSOFT_TENANT_ID`
+- `MICROSOFT_CLIENT_ID`
+- `MICROSOFT_CLIENT_SECRET`
+- `VIIO_SYNC_API_ENDPOINT`
+- `VIIO_SYNC_API_KEY`
+- `VIIO_DIRECT_INTEGRATION_INSTALLATION_ID`
+
+The example creates and closes the client inside each invocation's event loop. This avoids retaining a gRPC AsyncIO
+channel across event loops when Lambda reuses a warm execution environment.
+
+`grpcio` contains native code. When creating a Lambda ZIP or layer on another operating system, ask pip for the
+matching Linux wheel:
+
+```shell
+# x86_64
+python -m pip install \
+  --platform manylinux2014_x86_64 \
+  --implementation cp \
+  --python-version 3.11 \
+  --only-binary=:all: \
+  --target package \
+  viio-sync-api-sdk
+
+# arm64
+python -m pip install \
+  --platform manylinux2014_aarch64 \
+  --implementation cp \
+  --python-version 3.11 \
+  --only-binary=:all: \
+  --target package \
+  viio-sync-api-sdk
+```
+
+Replace `3.11` with the Python version of the target Lambda runtime. The same package can be installed normally in AWS
+Lambda Python container images. Full API documentation is available at <https://developers.viio.io/sync-api>.
+
+## Authentication and transport security
+
+External integrations use API keys. Viio-managed callers can supply an asynchronous bearer-token provider.
+
+Sync API endpoints must use HTTPS. HTTP is accepted only for loopback endpoints during development. SDK exception
+messages and representations do not include keys or bearer tokens.
+
+## License
+
+MIT

viio_sync_api_sdk-0.1.0/examples/__init__.py

@@ -0,0 +1 @@
+"""Runnable SDK examples."""

viio_sync_api_sdk-0.1.0/examples/aws_lambda.py

@@ -0,0 +1,191 @@
+"""Nightly Microsoft Graph employee sync triggered by an EventBridge cron schedule.
+
+Grant the Microsoft Entra application the ``User.Read.All`` application permission and
+configure the environment variables documented in the package readme.
+"""
+
+import asyncio
+import json
+import os
+from typing import Any
+from urllib.parse import urlencode, urlsplit
+from urllib.request import Request, urlopen
+
+from viio_sync_api import SyncApiAuthentication, SyncApiClient, SyncApiClientOptions
+from viio_sync_api.v1 import (
+    Employee,
+    EmployeeRecords,
+    MicrosoftEmployeeDetails,
+    MicrosoftEmployeeOrgData,
+    SyncRecordsRequest,
+)
+
+_GRAPH_USERS_URL = "https://graph.microsoft.com/v1.0/users?" + urlencode(
+    {
+        "$select": ",".join(
+            (
+                "id",
+                "displayName",
+                "givenName",
+                "surname",
+                "mail",
+                "userPrincipalName",
+                "department",
+                "accountEnabled",
+                "createdDateTime",
+                "deletedDateTime",
+                "jobTitle",
+                "userType",
+                "country",
+                "employeeOrgData",
+            )
+        ),
+        "$top": "999",
+    }
+)
+
+
+def _request_graph_token() -> str:
+    tenant_id = os.environ["MICROSOFT_TENANT_ID"]
+    if not tenant_id or any(
+        character not in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-" for character in tenant_id
+    ):
+        raise ValueError("MICROSOFT_TENANT_ID must be a tenant ID or verified domain name")
+
+    request = Request(
+        f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token",
+        data=urlencode(
+            {
+                "grant_type": "client_credentials",
+                "client_id": os.environ["MICROSOFT_CLIENT_ID"],
+                "client_secret": os.environ["MICROSOFT_CLIENT_SECRET"],
+                "scope": "https://graph.microsoft.com/.default",
+            }
+        ).encode(),
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        method="POST",
+    )
+    payload = _request_json(request)
+    token = payload.get("access_token")
+    if not isinstance(token, str) or not token:
+        raise RuntimeError("Microsoft identity platform returned no access token")
+    return token
+
+
+def _request_graph_users(url: str, access_token: str) -> tuple[list[dict[str, Any]], str | None]:
+    parsed_url = urlsplit(url)
+    if parsed_url.scheme != "https" or parsed_url.hostname != "graph.microsoft.com":
+        raise RuntimeError("Microsoft Graph returned an invalid pagination URL")
+
+    payload = _request_json(
+        Request(
+            url,
+            headers={
+                "Accept": "application/json",
+                "Authorization": f"Bearer {access_token}",
+            },
+        )
+    )
+    users = payload.get("value")
+    if not isinstance(users, list) or not all(isinstance(user, dict) for user in users):
+        raise RuntimeError("Microsoft Graph returned an invalid users response")
+
+    next_url = payload.get("@odata.nextLink")
+    if next_url is not None and not isinstance(next_url, str):
+        raise RuntimeError("Microsoft Graph returned an invalid pagination URL")
+    return users, next_url
+
+
+def _request_json(request: Request) -> dict[str, Any]:
+    with urlopen(request, timeout=30) as response:
+        payload = json.load(response)
+    if not isinstance(payload, dict):
+        raise RuntimeError("Remote service returned an invalid JSON response")
+    return payload
+
+
+def _employee_from_graph_user(user: dict[str, Any]) -> Employee:
+    details = MicrosoftEmployeeDetails(
+        id=_required_string(user, "id"),
+        display_name=_required_string(user, "displayName"),
+        user_principal_name=_required_string(user, "userPrincipalName"),
+    )
+    for graph_name, proto_name in (
+        ("givenName", "given_name"),
+        ("surname", "surname"),
+        ("mail", "mail"),
+        ("department", "department"),
+        ("jobTitle", "job_title"),
+        ("userType", "user_type"),
+        ("country", "country"),
+    ):
+        value = user.get(graph_name)
+        if isinstance(value, str) and value:
+            setattr(details, proto_name, value)
+
+    account_enabled = user.get("accountEnabled")
+    if isinstance(account_enabled, bool):
+        details.account_enabled = account_enabled
+
+    created_date_time = user.get("createdDateTime")
+    if isinstance(created_date_time, str) and created_date_time:
+        details.created_date_time.FromJsonString(created_date_time)
+
+    deleted_date_time = user.get("deletedDateTime")
+    if isinstance(deleted_date_time, str) and deleted_date_time:
+        details.deleted_date_time.FromJsonString(deleted_date_time)
+
+    org_data = user.get("employeeOrgData")
+    if isinstance(org_data, dict):
+        mapped_org_data = MicrosoftEmployeeOrgData()
+        division = org_data.get("division")
+        if isinstance(division, str) and division:
+            mapped_org_data.division = division
+        cost_center = org_data.get("costCenter")
+        if isinstance(cost_center, str) and cost_center:
+            mapped_org_data.cost_center = cost_center
+        if mapped_org_data.ListFields():
+            details.employee_org_data.CopyFrom(mapped_org_data)
+
+    return Employee(microsoft=details)
+
+
+def _required_string(source: dict[str, Any], field: str) -> str:
+    value = source.get(field)
+    if not isinstance(value, str) or not value:
+        raise RuntimeError(f"Microsoft Graph user is missing {field}")
+    return value
+
+
+async def _sync_employees() -> int:
+    graph_token = await asyncio.to_thread(_request_graph_token)
+    options = SyncApiClientOptions(
+        endpoint=os.environ["VIIO_SYNC_API_ENDPOINT"],
+        authentication=SyncApiAuthentication.api_key(os.environ["VIIO_SYNC_API_KEY"]),
+    )
+    async with SyncApiClient(options) as client:
+        batch = await client.start_batch(os.environ["VIIO_DIRECT_INTEGRATION_INSTALLATION_ID"])
+        employee_count = 0
+        next_url: str | None = _GRAPH_USERS_URL
+        try:
+            while next_url is not None:
+                users, next_url = await asyncio.to_thread(_request_graph_users, next_url, graph_token)
+                if users:
+                    employees = [_employee_from_graph_user(user) for user in users]
+                    await batch.write(SyncRecordsRequest(employees=EmployeeRecords(records=employees)))
+                    employee_count += len(employees)
+
+            if employee_count == 0:
+                await batch.write(SyncRecordsRequest(employees=EmployeeRecords()))
+            await batch.complete()
+        except BaseException:
+            await batch.abort()
+            raise
+        return employee_count
+
+
+def lambda_handler(event: dict[str, Any], context: object) -> dict[str, Any]:
+    """Run one complete employee snapshot for the scheduled invocation."""
+    del event, context
+    employee_count = asyncio.run(_sync_employees())
+    return {"ok": True, "employee_count": employee_count}

viio_sync_api_sdk-0.1.0/examples/requirements.txt

@@ -0,0 +1 @@
+viio-sync-api-sdk

viio_sync_api_sdk-0.1.0/examples/template.yaml

@@ -0,0 +1,59 @@
+---
+AWSTemplateFormatVersion: "2010-09-09"
+Transform: AWS::Serverless-2016-10-31
+Description: Nightly Microsoft Graph employee sync to the Viio Sync API
+
+Parameters:
+  MicrosoftTenantId:
+    Type: String
+  MicrosoftClientId:
+    Type: String
+  MicrosoftClientSecret:
+    Type: String
+    NoEcho: true
+  ViioSyncApiEndpoint:
+    Type: String
+  ViioSyncApiKey:
+    Type: String
+    NoEcho: true
+  ViioDirectIntegrationInstallationId:
+    Type: String
+
+Resources:
+  EmployeeSyncFunction:
+    Type: AWS::Serverless::Function
+    Metadata:
+      checkov:
+        skip:
+          - id: CKV_AWS_115
+            comment: Reserved concurrency is deployment-specific and omitted from this example.
+          - id: CKV_AWS_116
+            comment: A production deployment should configure its preferred failure destination.
+          - id: CKV_AWS_117
+            comment: This example calls public Microsoft Graph and Viio API endpoints directly.
+          - id: CKV_AWS_173
+            comment: A production deployment should supply its preferred customer-managed KMS key.
+    Properties:
+      Architectures:
+        - arm64
+      CodeUri: .
+      Handler: aws_lambda.lambda_handler
+      Runtime: python3.11
+      MemorySize: 512
+      Timeout: 900
+      Environment:
+        Variables:
+          MICROSOFT_TENANT_ID: !Ref MicrosoftTenantId
+          MICROSOFT_CLIENT_ID: !Ref MicrosoftClientId
+          MICROSOFT_CLIENT_SECRET: !Ref MicrosoftClientSecret
+          VIIO_SYNC_API_ENDPOINT: !Ref ViioSyncApiEndpoint
+          VIIO_SYNC_API_KEY: !Ref ViioSyncApiKey
+          VIIO_DIRECT_INTEGRATION_INSTALLATION_ID:
+            Ref: ViioDirectIntegrationInstallationId
+      Events:
+        NightlyEmployeeSync:
+          Type: ScheduleV2
+          Properties:
+            Description: Synchronize Microsoft Graph employees every night
+            ScheduleExpression: cron(0 2 * * ? *)
+            ScheduleExpressionTimezone: UTC

viio_sync_api_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,74 @@
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "viio-sync-api-sdk"
+version = "0.1.0"
+description = "Async Python SDK for the Viio Sync API"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "Viio" }]
+keywords = ["viio", "sync", "grpc", "sdk"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Framework :: AsyncIO",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Typing :: Typed",
+]
+dependencies = [
+  "grpcio>=1.83,<2",
+  "protobuf>=7.35.1,<8",
+]
+
+[project.urls]
+Documentation = "https://developers.viio.io/sync-api"
+Changelog = "https://developers.viio.io/sync-api"
+
+[dependency-groups]
+dev = [
+  "build>=1.3,<2",
+  "grpcio-tools>=1.76,<2",
+  "hatchling>=1.27,<2",
+  "mypy>=1.17,<2",
+  "pytest>=8.4,<10",
+  "pytest-asyncio>=1.1,<2",
+  "ruff>=0.12,<1",
+  "types-grpcio>=1.0,<2",
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src",
+  "/examples",
+  "/README.md",
+  "/CHANGELOG.md",
+  "/LICENSE",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/viio_sync_api"]
+
+[tool.pytest.ini_options]
+addopts = "-ra"
+asyncio_mode = "auto"
+pythonpath = ["."]
+testpaths = ["tests"]
+
+[tool.ruff]
+extend-exclude = ["src/viio_sync_api/v1/*_pb2*"]
+line-length = 120
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "ASYNC", "RUF"]
+
+[tool.mypy]
+exclude = ["src/viio_sync_api/v1/.*_pb2.*\\.py"]
+python_version = "3.11"
+strict = true
+packages = ["viio_sync_api"]

viio_sync_api_sdk-0.1.0/src/viio_sync_api/__init__.py

@@ -0,0 +1,27 @@
+"""Async Python SDK for the Viio Sync API."""
+
+from ._auth import BearerTokenProvider, SyncApiAuthentication
+from ._client import SyncApiBatch, SyncApiClient
+from ._errors import (
+    SyncApiAuthenticationError,
+    SyncApiBatchAlreadyInProgressError,
+    SyncApiBatchStateError,
+    SyncApiClosedError,
+    SyncApiError,
+    SyncApiProtocolError,
+)
+from ._options import SyncApiClientOptions
+
+__all__ = [
+    "BearerTokenProvider",
+    "SyncApiAuthentication",
+    "SyncApiAuthenticationError",
+    "SyncApiBatch",
+    "SyncApiBatchAlreadyInProgressError",
+    "SyncApiBatchStateError",
+    "SyncApiClient",
+    "SyncApiClientOptions",
+    "SyncApiClosedError",
+    "SyncApiError",
+    "SyncApiProtocolError",
+]