ynab-api-cli 0.1.0__py3-none-any.whl

ynab_api_cli/generated/api/scheduled_transactions/update_scheduled_transaction.py

@@ -0,0 +1,63 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.put_scheduled_transaction_wrapper import (
+    PutScheduledTransactionWrapper,
+)
+from ynab_api_cli.generated.models.scheduled_transaction_response import (
+    ScheduledTransactionResponse,
+)
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import RequestValues, Response
+
+
+class Endpoint:
+    """Typed updateScheduledTransaction operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        scheduled_transaction_id: str,
+        body: PutScheduledTransactionWrapper,
+    ) -> Response[ErrorResponse | ScheduledTransactionResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "updateScheduledTransaction",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                    "scheduled_transaction_id": scheduled_transaction_id,
+                },
+                query={},
+                body=body,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = ScheduledTransactionResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | ScheduledTransactionResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            scheduled_transaction_id=request.value(
+                "path", "scheduled_transaction_id", TypeAdapter[str](str)
+            ),
+            body=TypeAdapter[PutScheduledTransactionWrapper](
+                PutScheduledTransactionWrapper
+            ).validate_python(request.body),
+        )

ynab_api_cli/generated/api/transactions/__init__.py

@@ -0,0 +1,3 @@
+"""Generated endpoint declarations."""
+
+from __future__ import annotations

ynab_api_cli/generated/api/transactions/create_transaction.py

@@ -0,0 +1,58 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.post_transactions_wrapper import (
+    PostTransactionsWrapper,
+)
+from ynab_api_cli.generated.models.save_transactions_response import (
+    SaveTransactionsResponse,
+)
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import RequestValues, Response
+
+
+class Endpoint:
+    """Typed createTransaction operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        body: PostTransactionsWrapper,
+    ) -> Response[ErrorResponse | SaveTransactionsResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "createTransaction",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                },
+                query={},
+                body=body,
+            ),
+        )
+        if raw.status == HTTPStatus.CREATED:
+            parsed = SaveTransactionsResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | SaveTransactionsResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            body=TypeAdapter[PostTransactionsWrapper](
+                PostTransactionsWrapper
+            ).validate_python(request.body),
+        )

ynab_api_cli/generated/api/transactions/delete_transaction.py

@@ -0,0 +1,54 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.transaction_response import TransactionResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response
+
+
+class Endpoint:
+    """Typed deleteTransaction operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        transaction_id: str,
+    ) -> Response[ErrorResponse | TransactionResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "deleteTransaction",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                    "transaction_id": transaction_id,
+                },
+                query={},
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = TransactionResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | TransactionResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            transaction_id=request.value(
+                "path", "transaction_id", TypeAdapter[str](str)
+            ),
+        )

ynab_api_cli/generated/api/transactions/get_transaction_by_id.py

@@ -0,0 +1,54 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.transaction_response import TransactionResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response
+
+
+class Endpoint:
+    """Typed getTransactionById operation."""
+
+    @classmethod
+    def execute(
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        transaction_id: str,
+    ) -> Response[ErrorResponse | TransactionResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "getTransactionById",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                    "transaction_id": transaction_id,
+                },
+                query={},
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = TransactionResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | TransactionResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            transaction_id=request.value(
+                "path", "transaction_id", TypeAdapter[str](str)
+            ),
+        )

ynab_api_cli/generated/api/transactions/get_transactions.py

@@ -0,0 +1,80 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+import datetime
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.get_transactions_type import GetTransactionsType
+from ynab_api_cli.generated.models.transactions_response import TransactionsResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response, Unset
+
+
+class Endpoint:
+    """Typed getTransactions operation."""
+
+    @classmethod
+    def execute(  # noqa: PLR0913 - preserve the endpoint contract.
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        since_date: datetime.date | Unset = UNSET,
+        until_date: datetime.date | Unset = UNSET,
+        type_: GetTransactionsType | Unset = UNSET,
+        last_knowledge_of_server: int | Unset = UNSET,
+    ) -> Response[ErrorResponse | TransactionsResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "getTransactions",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                },
+                query={
+                    "since_date": since_date,
+                    "until_date": until_date,
+                    "type": type_,
+                    "last_knowledge_of_server": last_knowledge_of_server,
+                },
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = TransactionsResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | TransactionsResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            since_date=request.value(
+                "query",
+                "since_date",
+                TypeAdapter[datetime.date | Unset](datetime.date | Unset),
+            ),
+            until_date=request.value(
+                "query",
+                "until_date",
+                TypeAdapter[datetime.date | Unset](datetime.date | Unset),
+            ),
+            type_=request.value(
+                "query",
+                "type",
+                TypeAdapter[GetTransactionsType | Unset](GetTransactionsType | Unset),
+            ),
+            last_knowledge_of_server=request.value(
+                "query",
+                "last_knowledge_of_server",
+                TypeAdapter[int | Unset](int | Unset),
+            ),
+        )

ynab_api_cli/generated/api/transactions/get_transactions_by_account.py

@@ -0,0 +1,87 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+import datetime
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.get_transactions_by_account_type import (
+    GetTransactionsByAccountType,
+)
+from ynab_api_cli.generated.models.transactions_response import TransactionsResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response, Unset
+
+
+class Endpoint:
+    """Typed getTransactionsByAccount operation."""
+
+    @classmethod
+    def execute(  # noqa: PLR0913 - preserve the endpoint contract.
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        account_id: str,
+        since_date: datetime.date | Unset = UNSET,
+        until_date: datetime.date | Unset = UNSET,
+        type_: GetTransactionsByAccountType | Unset = UNSET,
+        last_knowledge_of_server: int | Unset = UNSET,
+    ) -> Response[ErrorResponse | TransactionsResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "getTransactionsByAccount",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                    "account_id": account_id,
+                },
+                query={
+                    "since_date": since_date,
+                    "until_date": until_date,
+                    "type": type_,
+                    "last_knowledge_of_server": last_knowledge_of_server,
+                },
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = TransactionsResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | TransactionsResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            account_id=request.value("path", "account_id", TypeAdapter[str](str)),
+            since_date=request.value(
+                "query",
+                "since_date",
+                TypeAdapter[datetime.date | Unset](datetime.date | Unset),
+            ),
+            until_date=request.value(
+                "query",
+                "until_date",
+                TypeAdapter[datetime.date | Unset](datetime.date | Unset),
+            ),
+            type_=request.value(
+                "query",
+                "type",
+                TypeAdapter[GetTransactionsByAccountType | Unset](
+                    GetTransactionsByAccountType | Unset
+                ),
+            ),
+            last_knowledge_of_server=request.value(
+                "query",
+                "last_knowledge_of_server",
+                TypeAdapter[int | Unset](int | Unset),
+            ),
+        )

ynab_api_cli/generated/api/transactions/get_transactions_by_category.py

@@ -0,0 +1,89 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+import datetime
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.get_transactions_by_category_type import (
+    GetTransactionsByCategoryType,
+)
+from ynab_api_cli.generated.models.hybrid_transactions_response import (
+    HybridTransactionsResponse,
+)
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response, Unset
+
+
+class Endpoint:
+    """Typed getTransactionsByCategory operation."""
+
+    @classmethod
+    def execute(  # noqa: PLR0913 - preserve the endpoint contract.
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        category_id: str,
+        since_date: datetime.date | Unset = UNSET,
+        until_date: datetime.date | Unset = UNSET,
+        type_: GetTransactionsByCategoryType | Unset = UNSET,
+        last_knowledge_of_server: int | Unset = UNSET,
+    ) -> Response[ErrorResponse | HybridTransactionsResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "getTransactionsByCategory",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                    "category_id": category_id,
+                },
+                query={
+                    "since_date": since_date,
+                    "until_date": until_date,
+                    "type": type_,
+                    "last_knowledge_of_server": last_knowledge_of_server,
+                },
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = HybridTransactionsResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | HybridTransactionsResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            category_id=request.value("path", "category_id", TypeAdapter[str](str)),
+            since_date=request.value(
+                "query",
+                "since_date",
+                TypeAdapter[datetime.date | Unset](datetime.date | Unset),
+            ),
+            until_date=request.value(
+                "query",
+                "until_date",
+                TypeAdapter[datetime.date | Unset](datetime.date | Unset),
+            ),
+            type_=request.value(
+                "query",
+                "type",
+                TypeAdapter[GetTransactionsByCategoryType | Unset](
+                    GetTransactionsByCategoryType | Unset
+                ),
+            ),
+            last_knowledge_of_server=request.value(
+                "query",
+                "last_knowledge_of_server",
+                TypeAdapter[int | Unset](int | Unset),
+            ),
+        )

ynab_api_cli/generated/api/transactions/get_transactions_by_month.py

@@ -0,0 +1,87 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+import datetime
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.get_transactions_by_month_type import (
+    GetTransactionsByMonthType,
+)
+from ynab_api_cli.generated.models.transactions_response import TransactionsResponse
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response, Unset
+
+
+class Endpoint:
+    """Typed getTransactionsByMonth operation."""
+
+    @classmethod
+    def execute(  # noqa: PLR0913 - preserve the endpoint contract.
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        month: str,
+        since_date: datetime.date | Unset = UNSET,
+        until_date: datetime.date | Unset = UNSET,
+        type_: GetTransactionsByMonthType | Unset = UNSET,
+        last_knowledge_of_server: int | Unset = UNSET,
+    ) -> Response[ErrorResponse | TransactionsResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "getTransactionsByMonth",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                    "month": month,
+                },
+                query={
+                    "since_date": since_date,
+                    "until_date": until_date,
+                    "type": type_,
+                    "last_knowledge_of_server": last_knowledge_of_server,
+                },
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = TransactionsResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | TransactionsResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            month=request.value("path", "month", TypeAdapter[str](str)),
+            since_date=request.value(
+                "query",
+                "since_date",
+                TypeAdapter[datetime.date | Unset](datetime.date | Unset),
+            ),
+            until_date=request.value(
+                "query",
+                "until_date",
+                TypeAdapter[datetime.date | Unset](datetime.date | Unset),
+            ),
+            type_=request.value(
+                "query",
+                "type",
+                TypeAdapter[GetTransactionsByMonthType | Unset](
+                    GetTransactionsByMonthType | Unset
+                ),
+            ),
+            last_knowledge_of_server=request.value(
+                "query",
+                "last_knowledge_of_server",
+                TypeAdapter[int | Unset](int | Unset),
+            ),
+        )

ynab_api_cli/generated/api/transactions/get_transactions_by_payee.py

@@ -0,0 +1,89 @@
+"""Generated typed REST endpoint; regenerate rather than editing."""
+
+from __future__ import annotations
+
+import datetime
+from http import HTTPStatus
+
+from pydantic import TypeAdapter
+
+from ynab_api_cli.generated.models.error_response import ErrorResponse
+from ynab_api_cli.generated.models.get_transactions_by_payee_type import (
+    GetTransactionsByPayeeType,
+)
+from ynab_api_cli.generated.models.hybrid_transactions_response import (
+    HybridTransactionsResponse,
+)
+from ynab_api_cli.transport import Transport
+from ynab_api_cli.types import UNSET, RequestValues, Response, Unset
+
+
+class Endpoint:
+    """Typed getTransactionsByPayee operation."""
+
+    @classmethod
+    def execute(  # noqa: PLR0913 - preserve the endpoint contract.
+        cls,
+        *,
+        transport: Transport,
+        plan_id: str,
+        payee_id: str,
+        since_date: datetime.date | Unset = UNSET,
+        until_date: datetime.date | Unset = UNSET,
+        type_: GetTransactionsByPayeeType | Unset = UNSET,
+        last_knowledge_of_server: int | Unset = UNSET,
+    ) -> Response[ErrorResponse | HybridTransactionsResponse]:
+        """Execute the typed request and retain its original response JSON."""
+        raw = transport.send(
+            "getTransactionsByPayee",
+            RequestValues(
+                path={
+                    "plan_id": plan_id,
+                    "payee_id": payee_id,
+                },
+                query={
+                    "since_date": since_date,
+                    "until_date": until_date,
+                    "type": type_,
+                    "last_knowledge_of_server": last_knowledge_of_server,
+                },
+                body=UNSET,
+            ),
+        )
+        if raw.status == HTTPStatus.OK:
+            parsed = HybridTransactionsResponse.model_validate(raw.raw)
+            return Response(raw.status, raw.raw, raw.headers, parsed)
+        raise ValueError("Validated response has no generated success binding.")
+
+    @classmethod
+    def dispatch(
+        cls, transport: Transport, request: RequestValues
+    ) -> Response[ErrorResponse | HybridTransactionsResponse]:
+        """Convert validated CLI inputs and call the explicitly typed method."""
+        return cls.execute(
+            transport=transport,
+            plan_id=request.value("path", "plan_id", TypeAdapter[str](str)),
+            payee_id=request.value("path", "payee_id", TypeAdapter[str](str)),
+            since_date=request.value(
+                "query",
+                "since_date",
+                TypeAdapter[datetime.date | Unset](datetime.date | Unset),
+            ),
+            until_date=request.value(
+                "query",
+                "until_date",
+                TypeAdapter[datetime.date | Unset](datetime.date | Unset),
+            ),
+            type_=request.value(
+                "query",
+                "type",
+                TypeAdapter[GetTransactionsByPayeeType | Unset](
+                    GetTransactionsByPayeeType | Unset
+                ),
+            ),
+            last_knowledge_of_server=request.value(
+                "query",
+                "last_knowledge_of_server",
+                TypeAdapter[int | Unset](int | Unset),
+            ),
+        )