fivetran-cli 0.1.0__py3-none-any.whl

fivetran_cli/cli.py

@@ -0,0 +1,1472 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import tomllib
+import urllib.parse
+from dataclasses import dataclass
+from difflib import get_close_matches
+from pathlib import Path
+from typing import Any, Callable, Sequence, TextIO
+
+from .client import DEFAULT_BASE_URL, CliError, ClientConfig, FivetranClient
+from .output import emit_output
+
+
+Handler = Callable[[argparse.Namespace, FivetranClient], Any]
+GLOBAL_OPTIONS_WITH_VALUES = {
+    "--api-key",
+    "--api-secret",
+    "--profile",
+    "--base-url",
+    "--format",
+    "--output",
+}
+GLOBAL_FLAG_OPTIONS = {"--quiet", "--verbose"}
+OPERATION_EPILOG = (
+    "Credentials default to FIVETRAN_API_KEY and FIVETRAN_API_SECRET. "
+    "FIVETRAN_BASE_URL overrides the default API base URL. "
+    "Global options may be placed before or after the resource command."
+)
+PUBLIC_OPERATION_EPILOG = (
+    "This command does not require Fivetran API credentials. "
+    "FIVETRAN_BASE_URL overrides the default API base URL. "
+    "Global options may be placed before or after the resource command."
+)
+
+
+@dataclass(frozen=True)
+class Endpoint:
+    method: str
+    path_template: str
+    id_args: tuple[str, ...] = ()
+    query_args: tuple[str, ...] = ()
+    body_required: bool = False
+    body_optional: bool = False
+    destructive: bool = False
+    paginated: bool = False
+    auth_required: bool = True
+
+
+class SuggestingParser(argparse.ArgumentParser):
+    def error(self, message: str) -> None:
+        suggestion = _suggestion(message, self)
+        if suggestion:
+            message = f"{message}\n\nDid you mean '{suggestion}'?"
+        super().error(message)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    return run(argv if argv is not None else sys.argv[1:])
+
+
+def run(
+    argv: Sequence[str],
+    *,
+    client_factory: Callable[[ClientConfig], FivetranClient] = FivetranClient,
+    stdout: TextIO = sys.stdout,
+    stderr: TextIO = sys.stderr,
+) -> int:
+    parser = build_parser()
+    args = parser.parse_args(_normalize_global_options(list(argv)))
+    if not hasattr(args, "handler"):
+        parser.print_help(stdout)
+        return 0
+
+    try:
+        config = resolve_config(args)
+        client = client_factory(config)
+        payload = args.handler(args, client)
+        emit_output(
+            payload,
+            output_format=args.format,
+            output_path=args.output,
+            quiet=args.quiet,
+            stdout=stdout,
+        )
+        return 0
+    except CliError as exc:
+        stderr.write(f"fivetran: error: {exc}\n")
+        return 1
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = SuggestingParser(
+        prog="fivetran",
+        description="Command line wrapper for the Fivetran REST API.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        allow_abbrev=False,
+    )
+    _add_global_options(parser)
+
+    resources = parser.add_subparsers(dest="resource", metavar="<resource>")
+    _add_account(resources)
+    _add_connection(resources)
+    _add_destination(resources)
+    _add_group(resources)
+    _add_user(resources)
+    _add_team(resources)
+    _add_role(resources)
+    _add_system_key(resources)
+    _add_connection_schema(resources)
+    _add_connector_metadata(resources)
+    _add_public_connector(resources)
+    _add_hybrid_deployment_agent(resources)
+    _add_proxy_agent(resources)
+    _add_private_link(resources)
+    _add_transformation(resources)
+    return parser
+
+
+def _add_global_options(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--api-key", help="Fivetran API key. Defaults to FIVETRAN_API_KEY.")
+    parser.add_argument(
+        "--api-secret",
+        help="Fivetran API secret. Defaults to FIVETRAN_API_SECRET.",
+    )
+    parser.add_argument("--profile", help="Named credential profile.")
+    parser.add_argument(
+        "--base-url",
+        help="Fivetran API base URL. Defaults to FIVETRAN_BASE_URL or https://api.fivetran.com.",
+    )
+    parser.add_argument(
+        "--format",
+        choices=("json", "table", "yaml"),
+        default="json",
+        help="Output format.",
+    )
+    parser.add_argument("--output", help="Write output to a path instead of stdout.")
+    parser.add_argument("--quiet", action="store_true", help="Suppress response output.")
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose diagnostics.")
+
+
+def _add_account(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    account = resources.add_parser(
+        "account",
+        help="Manage account-level information.",
+        description="Manage account-level information.",
+    )
+    operations = account.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get account information.",
+        Endpoint("GET", "/v1/account/info"),
+        epilog=(
+            "Example: fivetran account get\n\n"
+            "Note: this uses the current Fivetran account info endpoint, /v1/account/info."
+        ),
+    )
+
+
+def _add_connection(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    connection = resources.add_parser(
+        "connection",
+        help="Create, configure, and manage connections.",
+        description="Create, configure, and manage connections.",
+    )
+    operations = connection.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List connections.",
+        Endpoint(
+            "GET",
+            "/v1/connections",
+            query_args=("group_id", "schema", "limit", "cursor"),
+            paginated=True,
+        ),
+        query_options=(("group-id", "group_id"), ("schema", "schema")),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get a connection.",
+        Endpoint("GET", "/v1/connections/{connection_id}", id_args=("connection_id",)),
+        arguments=(("connection_id", "Connection ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "create",
+        "Create a connection.",
+        Endpoint("POST", "/v1/connections", body_required=True),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "update",
+        "Update a connection.",
+        Endpoint(
+            "PATCH",
+            "/v1/connections/{connection_id}",
+            id_args=("connection_id",),
+            body_required=True,
+        ),
+        arguments=(("connection_id", "Connection ID."),),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "delete",
+        "Delete a connection.",
+        Endpoint(
+            "DELETE",
+            "/v1/connections/{connection_id}",
+            id_args=("connection_id",),
+            destructive=True,
+        ),
+        arguments=(("connection_id", "Connection ID."),),
+        destructive=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "sync",
+        "Trigger a connection sync.",
+        Endpoint(
+            "POST",
+            "/v1/connections/{connection_id}/sync",
+            id_args=("connection_id",),
+            body_optional=True,
+        ),
+        arguments=(("connection_id", "Connection ID."),),
+        body=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "resync",
+        "Trigger a historical connection re-sync.",
+        Endpoint(
+            "POST",
+            "/v1/connections/{connection_id}/resync",
+            id_args=("connection_id",),
+            body_optional=True,
+        ),
+        arguments=(("connection_id", "Connection ID."),),
+        body=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "test",
+        "Run connection setup tests.",
+        Endpoint("POST", "/v1/connections/{connection_id}/test", id_args=("connection_id",)),
+        arguments=(("connection_id", "Connection ID."),),
+    )
+
+
+def _add_destination(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    destination = resources.add_parser(
+        "destination",
+        help="Create and manage destinations.",
+        description="Create and manage destinations.",
+    )
+    operations = destination.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List destinations.",
+        Endpoint("GET", "/v1/destinations", query_args=("limit", "cursor"), paginated=True),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get a destination.",
+        Endpoint("GET", "/v1/destinations/{destination_id}", id_args=("destination_id",)),
+        arguments=(("destination_id", "Destination ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "create",
+        "Create a destination.",
+        Endpoint("POST", "/v1/destinations", body_required=True),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "update",
+        "Update a destination.",
+        Endpoint(
+            "PATCH",
+            "/v1/destinations/{destination_id}",
+            id_args=("destination_id",),
+            body_required=True,
+        ),
+        arguments=(("destination_id", "Destination ID."),),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "delete",
+        "Delete a destination.",
+        Endpoint(
+            "DELETE",
+            "/v1/destinations/{destination_id}",
+            id_args=("destination_id",),
+            destructive=True,
+        ),
+        arguments=(("destination_id", "Destination ID."),),
+        destructive=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "test",
+        "Run destination setup tests.",
+        Endpoint(
+            "POST",
+            "/v1/destinations/{destination_id}/test",
+            id_args=("destination_id",),
+        ),
+        arguments=(("destination_id", "Destination ID."),),
+    )
+
+
+def _add_group(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    group = resources.add_parser(
+        "group",
+        help="Manage groups that organize connections and destinations.",
+        description="Manage groups that organize connections and destinations.",
+    )
+    operations = group.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List groups.",
+        Endpoint("GET", "/v1/groups", query_args=("limit", "cursor"), paginated=True),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get a group.",
+        Endpoint("GET", "/v1/groups/{group_id}", id_args=("group_id",)),
+        arguments=(("group_id", "Group ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "create",
+        "Create a group.",
+        Endpoint("POST", "/v1/groups", body_required=True),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "update",
+        "Update a group.",
+        Endpoint("PATCH", "/v1/groups/{group_id}", id_args=("group_id",), body_required=True),
+        arguments=(("group_id", "Group ID."),),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "delete",
+        "Delete a group.",
+        Endpoint("DELETE", "/v1/groups/{group_id}", id_args=("group_id",), destructive=True),
+        arguments=(("group_id", "Group ID."),),
+        destructive=True,
+    )
+    _add_group_get_subresource(
+        operations,
+        "public-key",
+        "public key",
+        "/v1/groups/{group_id}/public-key",
+    )
+    _add_group_get_subresource(
+        operations,
+        "service-account",
+        "service account",
+        "/v1/groups/{group_id}/service-account",
+    )
+    _add_group_connection_commands(operations)
+    _add_group_user_commands(operations)
+
+
+def _add_group_get_subresource(
+    operations: argparse._SubParsersAction[argparse.ArgumentParser],
+    name: str,
+    label: str,
+    path: str,
+) -> None:
+    parser = operations.add_parser(
+        name,
+        help=f"Manage group {label}.",
+        description=f"Manage group {label}.",
+    )
+    subresource_ops = parser.add_subparsers(dest=f"{name.replace('-', '_')}_operation", required=True)
+    _add_endpoint_command(
+        subresource_ops,
+        "get",
+        f"Get a group's {label}.",
+        Endpoint("GET", path, id_args=("group_id",)),
+        arguments=(("group_id", "Group ID."),),
+    )
+
+
+def _add_group_connection_commands(
+    operations: argparse._SubParsersAction[argparse.ArgumentParser],
+) -> None:
+    connection = operations.add_parser(
+        "connection",
+        help="Manage group connections.",
+        description="Manage group connections.",
+    )
+    connection_ops = connection.add_subparsers(dest="connection_operation", required=True)
+    _add_endpoint_command(
+        connection_ops,
+        "list",
+        "List group connections.",
+        Endpoint(
+            "GET",
+            "/v1/groups/{group_id}/connections",
+            id_args=("group_id",),
+            query_args=("limit", "cursor"),
+            paginated=True,
+        ),
+        arguments=(("group_id", "Group ID."),),
+        pagination=True,
+    )
+
+
+def _add_group_user_commands(
+    operations: argparse._SubParsersAction[argparse.ArgumentParser],
+) -> None:
+    user = operations.add_parser(
+        "user",
+        help="Manage group users.",
+        description="Manage group users.",
+    )
+    user_ops = user.add_subparsers(dest="user_operation", required=True)
+    _add_endpoint_command(
+        user_ops,
+        "list",
+        "List group users.",
+        Endpoint(
+            "GET",
+            "/v1/groups/{group_id}/users",
+            id_args=("group_id",),
+            query_args=("limit", "cursor"),
+            paginated=True,
+        ),
+        arguments=(("group_id", "Group ID."),),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        user_ops,
+        "add",
+        "Add a user to a group.",
+        Endpoint("POST", "/v1/groups/{group_id}/users", id_args=("group_id",), body_required=True),
+        arguments=(("group_id", "Group ID."),),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        user_ops,
+        "remove",
+        "Remove a user from a group.",
+        Endpoint(
+            "DELETE",
+            "/v1/groups/{group_id}/users/{user_id}",
+            id_args=("group_id", "user_id"),
+            destructive=True,
+        ),
+        arguments=(("group_id", "Group ID."), ("user_id", "User ID.")),
+        destructive=True,
+    )
+
+
+def _add_user(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    user = resources.add_parser(
+        "user",
+        help="Manage user accounts and access.",
+        description="Manage user accounts and access.",
+    )
+    operations = user.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List users.",
+        Endpoint("GET", "/v1/users", query_args=("limit", "cursor"), paginated=True),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get a user.",
+        Endpoint("GET", "/v1/users/{user_id}", id_args=("user_id",)),
+        arguments=(("user_id", "User ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "invite",
+        "Invite a user.",
+        Endpoint("POST", "/v1/users", body_required=True),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "update",
+        "Update a user.",
+        Endpoint("PATCH", "/v1/users/{user_id}", id_args=("user_id",), body_required=True),
+        arguments=(("user_id", "User ID."),),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "delete",
+        "Delete a user.",
+        Endpoint("DELETE", "/v1/users/{user_id}", id_args=("user_id",), destructive=True),
+        arguments=(("user_id", "User ID."),),
+        destructive=True,
+    )
+    _add_account_role_remove(operations, "/v1/users/{user_id}/role", "user_id", "User ID.")
+    _add_user_membership_group(
+        operations,
+        "connection",
+        "connection_id",
+        "Connection ID.",
+        "/v1/users/{user_id}/connections",
+        "/v1/users/{user_id}/connections/{connection_id}",
+        first_id=("user_id", "User ID."),
+        add_requires_second_id=False,
+    )
+    _add_user_membership_group(
+        operations,
+        "group",
+        "group_id",
+        "Group ID.",
+        "/v1/users/{user_id}/groups",
+        "/v1/users/{user_id}/groups/{group_id}",
+        first_id=("user_id", "User ID."),
+        add_requires_second_id=False,
+    )
+
+
+def _add_team(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    team = resources.add_parser(
+        "team",
+        help="Manage teams and their access.",
+        description="Manage teams and their access.",
+    )
+    operations = team.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List teams.",
+        Endpoint("GET", "/v1/teams", query_args=("limit", "cursor"), paginated=True),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get a team.",
+        Endpoint("GET", "/v1/teams/{team_id}", id_args=("team_id",)),
+        arguments=(("team_id", "Team ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "create",
+        "Create a team.",
+        Endpoint("POST", "/v1/teams", body_required=True),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "update",
+        "Update a team.",
+        Endpoint("PATCH", "/v1/teams/{team_id}", id_args=("team_id",), body_required=True),
+        arguments=(("team_id", "Team ID."),),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "delete",
+        "Delete a team.",
+        Endpoint("DELETE", "/v1/teams/{team_id}", id_args=("team_id",), destructive=True),
+        arguments=(("team_id", "Team ID."),),
+        destructive=True,
+    )
+    _add_account_role_remove(operations, "/v1/teams/{team_id}/role", "team_id", "Team ID.")
+    _add_user_membership_group(
+        operations,
+        "connection",
+        "connection_id",
+        "Connection ID.",
+        "/v1/teams/{team_id}/connections",
+        "/v1/teams/{team_id}/connections/{connection_id}",
+        first_id=("team_id", "Team ID."),
+        add_requires_second_id=True,
+    )
+    _add_user_membership_group(
+        operations,
+        "group",
+        "group_id",
+        "Group ID.",
+        "/v1/teams/{team_id}/groups",
+        "/v1/teams/{team_id}/groups/{group_id}",
+        first_id=("team_id", "Team ID."),
+        add_requires_second_id=True,
+    )
+    _add_user_membership_group(
+        operations,
+        "user",
+        "user_id",
+        "User ID.",
+        "/v1/teams/{team_id}/users",
+        "/v1/teams/{team_id}/users/{user_id}",
+        first_id=("team_id", "Team ID."),
+        add_requires_second_id=False,
+    )
+
+
+def _add_role(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    role = resources.add_parser(
+        "role",
+        help="Retrieve available roles and permissions.",
+        description="Retrieve available roles and permissions.",
+    )
+    operations = role.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List roles.",
+        Endpoint("GET", "/v1/roles", query_args=("limit", "cursor"), paginated=True),
+        pagination=True,
+    )
+
+
+def _add_system_key(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    system_key = resources.add_parser(
+        "system-key",
+        help="Manage system keys.",
+        description="Manage system keys.",
+    )
+    operations = system_key.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List system keys.",
+        Endpoint("GET", "/v1/system-keys", query_args=("limit", "cursor"), paginated=True),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get a system key.",
+        Endpoint("GET", "/v1/system-keys/{key_id}", id_args=("key_id",)),
+        arguments=(("key_id", "System key ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "create",
+        "Create a system key.",
+        Endpoint("POST", "/v1/system-keys", body_required=True),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "update",
+        "Update a system key.",
+        Endpoint("PATCH", "/v1/system-keys/{key_id}", id_args=("key_id",), body_required=True),
+        arguments=(("key_id", "System key ID."),),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "delete",
+        "Delete a system key.",
+        Endpoint("DELETE", "/v1/system-keys/{key_id}", id_args=("key_id",), destructive=True),
+        arguments=(("key_id", "System key ID."),),
+        destructive=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "rotate",
+        "Rotate a system key.",
+        Endpoint(
+            "POST",
+            "/v1/system-keys/{key_id}/rotate",
+            id_args=("key_id",),
+            body_optional=True,
+        ),
+        arguments=(("key_id", "System key ID."),),
+        body=True,
+    )
+
+
+def _add_connection_schema(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    connection_schema = resources.add_parser(
+        "connection-schema",
+        help="Manage connection schema configuration.",
+        description="Manage connection schema configuration.",
+    )
+    operations = connection_schema.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get connection schema configuration.",
+        Endpoint("GET", "/v1/connections/{connection_id}/schemas", id_args=("connection_id",)),
+        arguments=(("connection_id", "Connection ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "setup",
+        "Set up connection schema configuration.",
+        Endpoint(
+            "POST",
+            "/v1/connections/{connection_id}/schemas",
+            id_args=("connection_id",),
+            body_required=True,
+        ),
+        arguments=(("connection_id", "Connection ID."),),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "update",
+        "Update connection schema configuration.",
+        Endpoint(
+            "PATCH",
+            "/v1/connections/{connection_id}/schemas",
+            id_args=("connection_id",),
+            body_required=True,
+        ),
+        arguments=(("connection_id", "Connection ID."),),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "reload",
+        "Reload connection schema configuration.",
+        Endpoint("POST", "/v1/connections/{connection_id}/schemas/reload", id_args=("connection_id",)),
+        arguments=(("connection_id", "Connection ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "resync-table",
+        "Re-sync connection table data.",
+        Endpoint(
+            "POST",
+            "/v1/connections/{connection_id}/schemas/tables/resync",
+            id_args=("connection_id",),
+            body_required=True,
+        ),
+        arguments=(("connection_id", "Connection ID."),),
+        body=True,
+        body_required=True,
+    )
+    _add_connection_schema_schema_commands(operations)
+    _add_connection_schema_table_commands(operations)
+    _add_connection_schema_column_commands(operations)
+
+
+def _add_connection_schema_schema_commands(
+    operations: argparse._SubParsersAction[argparse.ArgumentParser],
+) -> None:
+    schema = operations.add_parser(
+        "schema",
+        help="Manage a database schema within a connection schema config.",
+        description="Manage a database schema within a connection schema config.",
+    )
+    schema_ops = schema.add_subparsers(dest="schema_operation", required=True)
+    _add_endpoint_command(
+        schema_ops,
+        "update",
+        "Update a connection database schema config.",
+        Endpoint(
+            "PATCH",
+            "/v1/connections/{connection_id}/schemas/{schema_name}",
+            id_args=("connection_id", "schema_name"),
+            body_required=True,
+        ),
+        arguments=(("connection_id", "Connection ID."), ("schema_name", "Schema name.")),
+        body=True,
+        body_required=True,
+    )
+
+
+def _add_connection_schema_table_commands(
+    operations: argparse._SubParsersAction[argparse.ArgumentParser],
+) -> None:
+    table = operations.add_parser(
+        "table",
+        help="Manage table schema configuration.",
+        description="Manage table schema configuration.",
+    )
+    table_ops = table.add_subparsers(dest="table_operation", required=True)
+    _add_endpoint_command(
+        table_ops,
+        "update",
+        "Update a connection table config.",
+        Endpoint(
+            "PATCH",
+            "/v1/connections/{connection_id}/schemas/{schema_name}/tables/{table_name}",
+            id_args=("connection_id", "schema_name", "table_name"),
+            body_required=True,
+        ),
+        arguments=(
+            ("connection_id", "Connection ID."),
+            ("schema_name", "Schema name."),
+            ("table_name", "Table name."),
+        ),
+        body=True,
+        body_required=True,
+    )
+
+
+def _add_connection_schema_column_commands(
+    operations: argparse._SubParsersAction[argparse.ArgumentParser],
+) -> None:
+    column = operations.add_parser(
+        "column",
+        help="Manage column schema configuration.",
+        description="Manage column schema configuration.",
+    )
+    column_ops = column.add_subparsers(dest="column_operation", required=True)
+    _add_endpoint_command(
+        column_ops,
+        "list",
+        "List source table column config.",
+        Endpoint(
+            "GET",
+            "/v1/connections/{connection_id}/schemas/{schema_name}/tables/{table_name}/columns",
+            id_args=("connection_id", "schema_name", "table_name"),
+        ),
+        arguments=(
+            ("connection_id", "Connection ID."),
+            ("schema_name", "Schema name."),
+            ("table_name", "Table name."),
+        ),
+    )
+    _add_endpoint_command(
+        column_ops,
+        "update",
+        "Update a connection column config.",
+        Endpoint(
+            "PATCH",
+            "/v1/connections/{connection_id}/schemas/{schema_name}/tables/{table_name}/columns/{column_name}",
+            id_args=("connection_id", "schema_name", "table_name", "column_name"),
+            body_required=True,
+        ),
+        arguments=(
+            ("connection_id", "Connection ID."),
+            ("schema_name", "Schema name."),
+            ("table_name", "Table name."),
+            ("column_name", "Column name."),
+        ),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        column_ops,
+        "drop",
+        "Drop a blocked column from the destination.",
+        Endpoint(
+            "DELETE",
+            "/v1/connections/{connection_id}/schemas/{schema_name}/tables/{table_name}/columns/{column_name}",
+            id_args=("connection_id", "schema_name", "table_name", "column_name"),
+            destructive=True,
+        ),
+        arguments=(
+            ("connection_id", "Connection ID."),
+            ("schema_name", "Schema name."),
+            ("table_name", "Table name."),
+            ("column_name", "Column name."),
+        ),
+        destructive=True,
+    )
+    _add_endpoint_command(
+        column_ops,
+        "drop-blocked",
+        "Drop blocked columns from the destination.",
+        Endpoint(
+            "POST",
+            "/v1/connections/{connection_id}/schemas/drop-columns",
+            id_args=("connection_id",),
+            body_required=True,
+            destructive=True,
+        ),
+        arguments=(("connection_id", "Connection ID."),),
+        body=True,
+        body_required=True,
+        destructive=True,
+    )
+
+
+def _add_connector_metadata(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    metadata = resources.add_parser(
+        "connector-metadata",
+        help="Retrieve authenticated connector metadata.",
+        description="Retrieve authenticated connector metadata.",
+    )
+    operations = metadata.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List connector metadata.",
+        Endpoint("GET", "/v1/metadata/connector-types", query_args=("limit", "cursor"), paginated=True),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get connector metadata.",
+        Endpoint("GET", "/v1/metadata/connector-types/{service}", id_args=("service",)),
+        arguments=(("service", "Connector service name."),),
+    )
+
+
+def _add_public_connector(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    public_connector = resources.add_parser(
+        "public-connector",
+        help="Discover public connector metadata without authentication.",
+        description="Discover public connector metadata without authentication.",
+    )
+    operations = public_connector.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List public connector metadata.",
+        Endpoint("GET", "/public/connector-types", auth_required=False),
+    )
+
+
+def _add_hybrid_deployment_agent(
+    resources: argparse._SubParsersAction[argparse.ArgumentParser],
+) -> None:
+    agent = resources.add_parser(
+        "hybrid-deployment-agent",
+        help="Manage Hybrid Deployment agents.",
+        description="Manage Hybrid Deployment agents.",
+    )
+    operations = agent.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List Hybrid Deployment agents.",
+        Endpoint(
+            "GET",
+            "/v1/hybrid-deployment-agents",
+            query_args=("group_id", "limit", "cursor"),
+            paginated=True,
+        ),
+        query_options=(("group-id", "group_id"),),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get Hybrid Deployment agent details.",
+        Endpoint("GET", "/v1/hybrid-deployment-agents/{agent_id}", id_args=("agent_id",)),
+        arguments=(("agent_id", "Agent ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "create",
+        "Create a Hybrid Deployment agent.",
+        Endpoint("POST", "/v1/hybrid-deployment-agents", body_required=True),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "delete",
+        "Delete a Hybrid Deployment agent.",
+        Endpoint(
+            "DELETE",
+            "/v1/hybrid-deployment-agents/{agent_id}",
+            id_args=("agent_id",),
+            destructive=True,
+        ),
+        arguments=(("agent_id", "Agent ID."),),
+        destructive=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "regenerate-auth",
+        "Regenerate Hybrid Deployment agent authentication.",
+        Endpoint(
+            "PATCH",
+            "/v1/hybrid-deployment-agents/{agent_id}/re-auth",
+            id_args=("agent_id",),
+        ),
+        arguments=(("agent_id", "Agent ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "reset-credentials",
+        "Reset Hybrid Deployment agent credentials.",
+        Endpoint(
+            "POST",
+            "/v1/hybrid-deployment-agents/{agent_id}/reset-credentials",
+            id_args=("agent_id",),
+            body_required=True,
+        ),
+        arguments=(("agent_id", "Agent ID."),),
+        body=True,
+        body_required=True,
+    )
+
+
+def _add_proxy_agent(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    agent = resources.add_parser(
+        "proxy-agent",
+        help="Manage proxy agents.",
+        description="Manage proxy agents.",
+    )
+    operations = agent.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List proxy agents.",
+        Endpoint("GET", "/v1/proxy", query_args=("limit", "cursor"), paginated=True),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get proxy agent details.",
+        Endpoint("GET", "/v1/proxy/{agent_id}", id_args=("agent_id",)),
+        arguments=(("agent_id", "Agent ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "create",
+        "Create a proxy agent.",
+        Endpoint("POST", "/v1/proxy", body_required=True),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "delete",
+        "Delete a proxy agent.",
+        Endpoint("DELETE", "/v1/proxy/{agent_id}", id_args=("agent_id",), destructive=True),
+        arguments=(("agent_id", "Agent ID."),),
+        destructive=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "regenerate-secrets",
+        "Regenerate proxy agent secrets.",
+        Endpoint("POST", "/v1/proxy/{agent_id}/regenerate-secrets", id_args=("agent_id",)),
+        arguments=(("agent_id", "Agent ID."),),
+    )
+    _add_proxy_agent_connection_commands(operations)
+
+
+def _add_proxy_agent_connection_commands(
+    operations: argparse._SubParsersAction[argparse.ArgumentParser],
+) -> None:
+    connection = operations.add_parser(
+        "connection",
+        help="List proxy agent connections.",
+        description="List proxy agent connections.",
+    )
+    connection_ops = connection.add_subparsers(dest="connection_operation", required=True)
+    _add_endpoint_command(
+        connection_ops,
+        "list",
+        "List connections attached to a proxy agent.",
+        Endpoint(
+            "GET",
+            "/v1/proxy/{agent_id}/connections",
+            id_args=("agent_id",),
+            query_args=("limit", "cursor"),
+            paginated=True,
+        ),
+        arguments=(("agent_id", "Agent ID."),),
+        pagination=True,
+    )
+
+
+def _add_private_link(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    private_link = resources.add_parser(
+        "private-link",
+        help="Manage private links.",
+        description="Manage private links.",
+    )
+    operations = private_link.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List private links.",
+        Endpoint("GET", "/v1/private-links", query_args=("limit", "cursor"), paginated=True),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "get",
+        "Get private link details.",
+        Endpoint("GET", "/v1/private-links/{private_link_id}", id_args=("private_link_id",)),
+        arguments=(("private_link_id", "Private link ID."),),
+    )
+    _add_endpoint_command(
+        operations,
+        "create",
+        "Create a private link.",
+        Endpoint("POST", "/v1/private-links", body_required=True),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "update",
+        "Update a private link.",
+        Endpoint(
+            "PATCH",
+            "/v1/private-links/{private_link_id}",
+            id_args=("private_link_id",),
+            body_required=True,
+        ),
+        arguments=(("private_link_id", "Private link ID."),),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        operations,
+        "delete",
+        "Delete a private link.",
+        Endpoint(
+            "DELETE",
+            "/v1/private-links/{private_link_id}",
+            id_args=("private_link_id",),
+            destructive=True,
+        ),
+        arguments=(("private_link_id", "Private link ID."),),
+        destructive=True,
+    )
+
+
+def _add_transformation(resources: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    transformation = resources.add_parser(
+        "transformation",
+        help="List transformations.",
+        description="List transformations.",
+    )
+    operations = transformation.add_subparsers(dest="operation", required=True)
+    _add_endpoint_command(
+        operations,
+        "list",
+        "List transformations.",
+        Endpoint("GET", "/v1/transformations", query_args=("limit", "cursor"), paginated=True),
+        pagination=True,
+    )
+
+
+def _add_account_role_remove(
+    operations: argparse._SubParsersAction[argparse.ArgumentParser],
+    path: str,
+    id_name: str,
+    id_help: str,
+) -> None:
+    account_role = operations.add_parser(
+        "account-role",
+        help="Manage account-level role assignment.",
+        description="Manage account-level role assignment.",
+    )
+    account_role_ops = account_role.add_subparsers(dest="account_role_operation", required=True)
+    _add_endpoint_command(
+        account_role_ops,
+        "remove",
+        "Remove account-level role assignment.",
+        Endpoint("DELETE", path, id_args=(id_name,), destructive=True),
+        arguments=((id_name, id_help),),
+        destructive=True,
+    )
+
+
+def _add_user_membership_group(
+    operations: argparse._SubParsersAction[argparse.ArgumentParser],
+    name: str,
+    member_id_name: str,
+    member_id_help: str,
+    collection_path: str,
+    item_path: str,
+    *,
+    first_id: tuple[str, str],
+    add_requires_second_id: bool,
+) -> None:
+    group = operations.add_parser(
+        name,
+        help=f"Manage {name} memberships.",
+        description=f"Manage {name} memberships.",
+    )
+    group_ops = group.add_subparsers(dest=f"{name.replace('-', '_')}_operation", required=True)
+    first_id_name, first_id_help = first_id
+    _add_endpoint_command(
+        group_ops,
+        "list",
+        f"List {name} memberships.",
+        Endpoint("GET", collection_path, id_args=(first_id_name,), query_args=("limit", "cursor"), paginated=True),
+        arguments=((first_id_name, first_id_help),),
+        pagination=True,
+    )
+    _add_endpoint_command(
+        group_ops,
+        "get",
+        f"Get {name} membership.",
+        Endpoint("GET", item_path, id_args=(first_id_name, member_id_name)),
+        arguments=((first_id_name, first_id_help), (member_id_name, member_id_help)),
+    )
+    add_path = item_path if add_requires_second_id else collection_path
+    add_ids = (first_id_name, member_id_name) if add_requires_second_id else (first_id_name,)
+    add_arguments = (
+        ((first_id_name, first_id_help), (member_id_name, member_id_help))
+        if add_requires_second_id
+        else ((first_id_name, first_id_help),)
+    )
+    _add_endpoint_command(
+        group_ops,
+        "add",
+        f"Add {name} membership.",
+        Endpoint("POST", add_path, id_args=add_ids, body_required=True),
+        arguments=add_arguments,
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        group_ops,
+        "update",
+        f"Update {name} membership.",
+        Endpoint("PATCH", item_path, id_args=(first_id_name, member_id_name), body_required=True),
+        arguments=((first_id_name, first_id_help), (member_id_name, member_id_help)),
+        body=True,
+        body_required=True,
+    )
+    _add_endpoint_command(
+        group_ops,
+        "remove",
+        f"Remove {name} membership.",
+        Endpoint("DELETE", item_path, id_args=(first_id_name, member_id_name), destructive=True),
+        arguments=((first_id_name, first_id_help), (member_id_name, member_id_help)),
+        destructive=True,
+    )
+
+
+def _add_endpoint_command(
+    operations: argparse._SubParsersAction[argparse.ArgumentParser],
+    name: str,
+    help_text: str,
+    endpoint: Endpoint,
+    *,
+    arguments: Sequence[tuple[str, str]] = (),
+    query_options: Sequence[tuple[str, str]] = (),
+    body: bool = False,
+    body_required: bool = False,
+    pagination: bool = False,
+    destructive: bool = False,
+    epilog: str | None = None,
+) -> None:
+    parser = operations.add_parser(
+        name,
+        help=help_text,
+        description=help_text,
+        epilog=_join_epilog(epilog, auth_required=endpoint.auth_required),
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    for arg_name, arg_help in arguments:
+        parser.add_argument(
+            arg_name,
+            metavar=f"<{arg_name.replace('_', '-')}>",
+            help=arg_help,
+        )
+    for flag, dest in query_options:
+        parser.add_argument(f"--{flag}", dest=dest)
+    if pagination:
+        parser.add_argument("--limit", type=int, help="Maximum items for one API page.")
+        parser.add_argument("--cursor", help="Pagination cursor to start from.")
+        parser.add_argument("--all", action="store_true", help="Follow pagination until exhausted.")
+    if body:
+        _add_body_options(parser, required=body_required)
+    if destructive:
+        parser.add_argument("--yes", action="store_true", help="Confirm the destructive operation.")
+    parser.set_defaults(handler=_handler(endpoint))
+
+
+def _join_epilog(epilog: str | None, *, auth_required: bool) -> str:
+    operation_epilog = OPERATION_EPILOG if auth_required else PUBLIC_OPERATION_EPILOG
+    if epilog:
+        return f"{epilog}\n\n{operation_epilog}"
+    return operation_epilog
+
+
+def _normalize_global_options(argv: list[str]) -> list[str]:
+    global_args: list[str] = []
+    command_args: list[str] = []
+    index = 0
+    while index < len(argv):
+        token = argv[index]
+        option_name = token.split("=", 1)[0]
+        if option_name in GLOBAL_OPTIONS_WITH_VALUES:
+            if "=" in token:
+                global_args.append(token)
+            elif index + 1 < len(argv):
+                global_args.extend([token, argv[index + 1]])
+                index += 1
+            else:
+                command_args.append(token)
+        elif token in GLOBAL_FLAG_OPTIONS:
+            global_args.append(token)
+        else:
+            command_args.append(token)
+        index += 1
+    return [*global_args, *command_args]
+
+
+def _add_body_options(parser: argparse.ArgumentParser, *, required: bool) -> None:
+    group = parser.add_mutually_exclusive_group(required=required)
+    group.add_argument("--data", help="Raw JSON request body.")
+    group.add_argument("--data-file", help="Path to a JSON request body, or '-' for stdin.")
+
+
+def _handler(endpoint: Endpoint) -> Handler:
+    def handle(args: argparse.Namespace, client: FivetranClient) -> Any:
+        if endpoint.destructive:
+            _confirm_destructive(args)
+
+        body = _load_body(args) if endpoint.body_required or endpoint.body_optional else None
+        path = _format_path(endpoint.path_template, args, endpoint.id_args)
+        query = {arg: getattr(args, arg, None) for arg in endpoint.query_args}
+
+        if endpoint.paginated and getattr(args, "all", False):
+            return client.paginated_request(
+                endpoint.method,
+                path,
+                query=query,
+                auth_required=endpoint.auth_required,
+            )
+        return client.request(
+            endpoint.method,
+            path,
+            query=query,
+            body=body,
+            auth_required=endpoint.auth_required,
+        )
+
+    return handle
+
+
+def _format_path(
+    path_template: str,
+    args: argparse.Namespace,
+    id_args: tuple[str, ...],
+) -> str:
+    path_args = {
+        arg: urllib.parse.quote(str(getattr(args, arg)), safe="")
+        for arg in id_args
+    }
+    return path_template.format(**path_args)
+
+
+def _load_body(args: argparse.Namespace) -> Any:
+    raw: str | None = None
+    if getattr(args, "data", None) is not None:
+        raw = args.data
+    elif getattr(args, "data_file", None) is not None:
+        if args.data_file == "-":
+            raw = sys.stdin.read()
+        else:
+            try:
+                raw = Path(args.data_file).read_text(encoding="utf-8")
+            except OSError as exc:
+                raise CliError(f"Could not read data file {args.data_file}: {exc}") from exc
+
+    if raw is None:
+        return None
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise CliError(f"Invalid JSON request body: {exc}") from exc
+
+
+def _confirm_destructive(args: argparse.Namespace) -> None:
+    if getattr(args, "yes", False):
+        return
+    if not sys.stdin.isatty():
+        raise CliError("This destructive operation requires --yes in non-interactive mode.")
+    target = " ".join(
+        str(getattr(args, name))
+        for name in vars(args)
+        if name.endswith("_id") and getattr(args, name, None)
+    )
+    prompt = f"Proceed with destructive operation{f' on {target}' if target else ''}? [y/N] "
+    if input(prompt).strip().lower() not in {"y", "yes"}:
+        raise CliError("Operation cancelled.")
+
+
+def resolve_config(args: argparse.Namespace) -> ClientConfig:
+    profile = _load_profile(args.profile) if args.profile else {}
+    api_key = args.api_key or profile.get("api_key") or os.environ.get("FIVETRAN_API_KEY")
+    api_secret = (
+        args.api_secret
+        or profile.get("api_secret")
+        or os.environ.get("FIVETRAN_API_SECRET")
+    )
+    base_url = (
+        args.base_url
+        or profile.get("base_url")
+        or os.environ.get("FIVETRAN_BASE_URL")
+        or DEFAULT_BASE_URL
+    )
+    return ClientConfig(
+        api_key=api_key,
+        api_secret=api_secret,
+        base_url=base_url,
+        verbose=args.verbose,
+    )
+
+
+def _load_profile(profile_name: str) -> dict[str, str]:
+    config_path = Path(
+        os.environ.get(
+            "FIVETRAN_CONFIG",
+            str(Path.home() / ".config" / "fivetran-cli" / "config.toml"),
+        )
+    )
+    if not config_path.exists():
+        raise CliError(f"Profile '{profile_name}' not found; config file does not exist: {config_path}")
+    try:
+        config = tomllib.loads(config_path.read_text(encoding="utf-8"))
+    except (OSError, tomllib.TOMLDecodeError) as exc:
+        raise CliError(f"Could not read config file {config_path}: {exc}") from exc
+    profiles = config.get("profiles", {})
+    profile = profiles.get(profile_name)
+    if not isinstance(profile, dict):
+        raise CliError(f"Profile '{profile_name}' not found in {config_path}")
+    return {str(key): str(value) for key, value in profile.items() if value is not None}
+
+
+def _suggestion(message: str, parser: argparse.ArgumentParser) -> str | None:
+    if "invalid choice:" not in message:
+        return None
+    parts = message.split("'")
+    if len(parts) < 2:
+        return None
+    invalid = parts[1]
+    choices = _subparser_choices(parser)
+    matches = get_close_matches(invalid, choices, n=1)
+    return matches[0] if matches else None
+
+
+def _subparser_choices(parser: argparse.ArgumentParser) -> list[str]:
+    choices: list[str] = []
+    for action in parser._actions:
+        if isinstance(action, argparse._SubParsersAction):
+            choices.extend(action.choices)
+    return choices