SymfWebAPI 1.26.10.1__py3-none-any.whl

SymfWebAPI/WebAPI/Interface/BankAccounts/Interfaces/IBankAccountsController/__init__.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Awaitable, List, overload
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.BankAccounts.ViewModels import BankAccount
+from ._common import (
+    _prepare_Get,
+    _prepare_GetListByContractor,
+    _prepare_Insert,
+    _prepare_Update,
+    _prepare_SetAsMain,
+)
+from ._ops import (
+    OP_Get,
+    OP_GetListByContractor,
+    OP_Insert,
+    OP_Update,
+    OP_SetAsMain,
+)
+
+@overload
+def Get(api: SyncInvokerProtocol, id: int) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Get(api: SyncRequestProtocol, id: int) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Get(api: AsyncInvokerProtocol, id: int) -> Awaitable[ResponseEnvelope[BankAccount]]: ...
+@overload
+def Get(api: AsyncRequestProtocol, id: int) -> Awaitable[ResponseEnvelope[BankAccount]]: ...
+def Get(api: object, id: int) -> ResponseEnvelope[BankAccount] | Awaitable[ResponseEnvelope[BankAccount]]:
+    params, data = _prepare_Get(id=id)
+    return invoke_operation(api, OP_Get, params=params, data=data)
+
+@overload
+def GetListByContractor(api: SyncInvokerProtocol, contractorCode: str) -> ResponseEnvelope[List[BankAccount]]: ...
+@overload
+def GetListByContractor(api: SyncRequestProtocol, contractorCode: str) -> ResponseEnvelope[List[BankAccount]]: ...
+@overload
+def GetListByContractor(api: AsyncInvokerProtocol, contractorCode: str) -> Awaitable[ResponseEnvelope[List[BankAccount]]]: ...
+@overload
+def GetListByContractor(api: AsyncRequestProtocol, contractorCode: str) -> Awaitable[ResponseEnvelope[List[BankAccount]]]: ...
+def GetListByContractor(api: object, contractorCode: str) -> ResponseEnvelope[List[BankAccount]] | Awaitable[ResponseEnvelope[List[BankAccount]]]:
+    params, data = _prepare_GetListByContractor(contractorCode=contractorCode)
+    return invoke_operation(api, OP_GetListByContractor, params=params, data=data)
+
+@overload
+def Insert(api: SyncInvokerProtocol, contractorCode: str, bankAccount: "BankAccount") -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Insert(api: SyncRequestProtocol, contractorCode: str, bankAccount: "BankAccount") -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Insert(api: AsyncInvokerProtocol, contractorCode: str, bankAccount: "BankAccount") -> Awaitable[ResponseEnvelope[BankAccount]]: ...
+@overload
+def Insert(api: AsyncRequestProtocol, contractorCode: str, bankAccount: "BankAccount") -> Awaitable[ResponseEnvelope[BankAccount]]: ...
+def Insert(api: object, contractorCode: str, bankAccount: "BankAccount") -> ResponseEnvelope[BankAccount] | Awaitable[ResponseEnvelope[BankAccount]]:
+    params, data = _prepare_Insert(contractorCode=contractorCode, bankAccount=bankAccount)
+    return invoke_operation(api, OP_Insert, params=params, data=data)
+
+@overload
+def Update(api: SyncInvokerProtocol, bankAccount: "BankAccount") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, bankAccount: "BankAccount") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: AsyncInvokerProtocol, bankAccount: "BankAccount") -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def Update(api: AsyncRequestProtocol, bankAccount: "BankAccount") -> Awaitable[ResponseEnvelope[None]]: ...
+def Update(api: object, bankAccount: "BankAccount") -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_Update(bankAccount=bankAccount)
+    return invoke_operation(api, OP_Update, params=params, data=data)
+
+@overload
+def SetAsMain(api: SyncInvokerProtocol, id: int) -> ResponseEnvelope[None]: ...
+@overload
+def SetAsMain(api: SyncRequestProtocol, id: int) -> ResponseEnvelope[None]: ...
+@overload
+def SetAsMain(api: AsyncInvokerProtocol, id: int) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def SetAsMain(api: AsyncRequestProtocol, id: int) -> Awaitable[ResponseEnvelope[None]]: ...
+def SetAsMain(api: object, id: int) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_SetAsMain(id=id)
+    return invoke_operation(api, OP_SetAsMain, params=params, data=data)
+
+__all__ = ["Get", "GetListByContractor", "Insert", "Update", "SetAsMain"]

SymfWebAPI/WebAPI/Interface/BankAccounts/Interfaces/IBankAccountsController/_common.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_Get = ('GET', '/api/BankAccounts')
+def _prepare_Get(*, id) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    data = None
+    return params or None, data
+
+_REQUEST_GetListByContractor = ('GET', '/api/BankAccounts')
+def _prepare_GetListByContractor(*, contractorCode) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["contractorCode"] = contractorCode
+    data = None
+    return params or None, data
+
+_REQUEST_Insert = ('POST', '/api/BankAccounts/Create')
+def _prepare_Insert(*, contractorCode, bankAccount) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["contractorCode"] = contractorCode
+    data = bankAccount.model_dump_json(exclude_unset=True) if bankAccount is not None else None
+    return params or None, data
+
+_REQUEST_Update = ('PUT', '/api/BankAccounts/Update')
+def _prepare_Update(*, bankAccount) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = bankAccount.model_dump_json(exclude_unset=True) if bankAccount is not None else None
+    return params or None, data
+
+_REQUEST_SetAsMain = ('PATCH', '/api/BankAccounts/SetAsMain')
+def _prepare_SetAsMain(*, id) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/BankAccounts/Interfaces/IBankAccountsController/_ops.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import List
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.BankAccounts.ViewModels import BankAccount
+
+_ADAPTER_Get = TypeAdapter(BankAccount)
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[BankAccount]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/BankAccounts', parser=_parse_Get)
+
+_ADAPTER_GetListByContractor = TypeAdapter(List[BankAccount])
+
+def _parse_GetListByContractor(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[BankAccount]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetListByContractor)
+OP_GetListByContractor = OperationSpec(method='GET', path='/api/BankAccounts', parser=_parse_GetListByContractor)
+
+_ADAPTER_Insert = TypeAdapter(BankAccount)
+
+def _parse_Insert(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[BankAccount]:
+    return parse_with_adapter(envelope, _ADAPTER_Insert)
+OP_Insert = OperationSpec(method='POST', path='/api/BankAccounts/Create', parser=_parse_Insert)
+
+def _parse_Update(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_Update = OperationSpec(method='PUT', path='/api/BankAccounts/Update', parser=_parse_Update)
+
+def _parse_SetAsMain(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_SetAsMain = OperationSpec(method='PATCH', path='/api/BankAccounts/SetAsMain', parser=_parse_SetAsMain)

SymfWebAPI/WebAPI/Interface/BankAccounts/Interfaces/__init__.py

@@ -0,0 +1,21 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("IBankAccountsController",)
+
+def __getattr__(name: str):
+    if name in __all__:
+        module = importlib.import_module(f".{name}", __name__)
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+def __dir__():
+    return sorted(set(__all__) | {n for n in globals() if not n.startswith('_')})
+
+if TYPE_CHECKING:
+    from . import IBankAccountsController as _IBankAccountsController

SymfWebAPI/WebAPI/Interface/BankAccounts/ViewModels/__init__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from typing import Optional
+from datetime import datetime
+
+class BankAccount(BaseModel):
+    Id: int
+    AccountNumber: str
+    BankName: str
+    Active: bool
+    Main: bool
+    SWIFT_BIC: str
+    WhiteList: Optional[bool]
+    WhiteListDate: Optional[datetime]

SymfWebAPI/WebAPI/Interface/BankAccounts/__init__.py

@@ -0,0 +1,22 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("Interfaces", "ViewModels",)
+
+def __getattr__(name: str):
+    if name in __all__:
+        module = importlib.import_module(f".{name}", __name__)
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+def __dir__():
+    return sorted(set(__all__) | {n for n in globals() if not n.startswith('_')})
+
+if TYPE_CHECKING:
+    from . import Interfaces as _Interfaces
+    from . import ViewModels as _ViewModels

SymfWebAPI/WebAPI/Interface/Common/Interfaces/ICurrencyRatesController/__init__.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Awaitable, List, Optional, overload
+from datetime import datetime
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels import CurrencyRate
+from ._common import (
+    _prepare_Get,
+    _prepare_GetList,
+    _prepare_GetListByCurrency,
+)
+from ._ops import (
+    OP_Get,
+    OP_GetList,
+    OP_GetListByCurrency,
+)
+
+@overload
+def Get(api: SyncInvokerProtocol, currencyId: int, date: Optional[datetime] = None) -> ResponseEnvelope[List[CurrencyRate]]: ...
+@overload
+def Get(api: SyncRequestProtocol, currencyId: int, date: Optional[datetime] = None) -> ResponseEnvelope[List[CurrencyRate]]: ...
+@overload
+def Get(api: AsyncInvokerProtocol, currencyId: int, date: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[CurrencyRate]]]: ...
+@overload
+def Get(api: AsyncRequestProtocol, currencyId: int, date: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[CurrencyRate]]]: ...
+def Get(api: object, currencyId: int, date: Optional[datetime] = None) -> ResponseEnvelope[List[CurrencyRate]] | Awaitable[ResponseEnvelope[List[CurrencyRate]]]:
+    params, data = _prepare_Get(currencyId=currencyId, date=date)
+    return invoke_operation(api, OP_Get, params=params, data=data)
+
+@overload
+def GetList(api: SyncInvokerProtocol, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[CurrencyRate]]: ...
+@overload
+def GetList(api: SyncRequestProtocol, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[CurrencyRate]]: ...
+@overload
+def GetList(api: AsyncInvokerProtocol, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[CurrencyRate]]]: ...
+@overload
+def GetList(api: AsyncRequestProtocol, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[CurrencyRate]]]: ...
+def GetList(api: object, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[CurrencyRate]] | Awaitable[ResponseEnvelope[List[CurrencyRate]]]:
+    params, data = _prepare_GetList(dateFrom=dateFrom, dateTo=dateTo)
+    return invoke_operation(api, OP_GetList, params=params, data=data)
+
+@overload
+def GetListByCurrency(api: SyncInvokerProtocol, currencyId: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[CurrencyRate]]: ...
+@overload
+def GetListByCurrency(api: SyncRequestProtocol, currencyId: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[CurrencyRate]]: ...
+@overload
+def GetListByCurrency(api: AsyncInvokerProtocol, currencyId: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[CurrencyRate]]]: ...
+@overload
+def GetListByCurrency(api: AsyncRequestProtocol, currencyId: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[CurrencyRate]]]: ...
+def GetListByCurrency(api: object, currencyId: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[CurrencyRate]] | Awaitable[ResponseEnvelope[List[CurrencyRate]]]:
+    params, data = _prepare_GetListByCurrency(currencyId=currencyId, dateFrom=dateFrom, dateTo=dateTo)
+    return invoke_operation(api, OP_GetListByCurrency, params=params, data=data)
+
+__all__ = ["Get", "GetList", "GetListByCurrency"]

SymfWebAPI/WebAPI/Interface/Common/Interfaces/ICurrencyRatesController/_common.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_Get = ('GET', '/api/CurrencyRates')
+def _prepare_Get(*, currencyId, date = None) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["currencyId"] = currencyId
+    if date is not None:
+        params["date"] = date
+    data = None
+    return params or None, data
+
+_REQUEST_GetList = ('GET', '/api/CurrencyRates/Filter')
+def _prepare_GetList(*, dateFrom = None, dateTo = None) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    if dateFrom is not None:
+        params["dateFrom"] = dateFrom
+    if dateTo is not None:
+        params["dateTo"] = dateTo
+    data = None
+    return params or None, data
+
+_REQUEST_GetListByCurrency = ('GET', '/api/CurrencyRates/Filter')
+def _prepare_GetListByCurrency(*, currencyId, dateFrom = None, dateTo = None) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["currencyId"] = currencyId
+    if dateFrom is not None:
+        params["dateFrom"] = dateFrom
+    if dateTo is not None:
+        params["dateTo"] = dateTo
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Common/Interfaces/ICurrencyRatesController/_ops.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import List, Optional
+from datetime import datetime
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels import CurrencyRate
+
+_ADAPTER_Get = TypeAdapter(List[CurrencyRate])
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[CurrencyRate]]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/CurrencyRates', parser=_parse_Get)
+
+_ADAPTER_GetList = TypeAdapter(List[CurrencyRate])
+
+def _parse_GetList(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[CurrencyRate]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetList)
+OP_GetList = OperationSpec(method='GET', path='/api/CurrencyRates/Filter', parser=_parse_GetList)
+
+_ADAPTER_GetListByCurrency = TypeAdapter(List[CurrencyRate])
+
+def _parse_GetListByCurrency(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[CurrencyRate]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetListByCurrency)
+OP_GetListByCurrency = OperationSpec(method='GET', path='/api/CurrencyRates/Filter', parser=_parse_GetListByCurrency)

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IDocumentSeriesController/__init__.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Awaitable, List, overload
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels import DocumentSeries
+from ._common import (
+    _prepare_Get,
+)
+from ._ops import (
+    OP_Get,
+)
+
+@overload
+def Get(api: SyncInvokerProtocol, documentTypeId: int) -> ResponseEnvelope[List[DocumentSeries]]: ...
+@overload
+def Get(api: SyncRequestProtocol, documentTypeId: int) -> ResponseEnvelope[List[DocumentSeries]]: ...
+@overload
+def Get(api: AsyncInvokerProtocol, documentTypeId: int) -> Awaitable[ResponseEnvelope[List[DocumentSeries]]]: ...
+@overload
+def Get(api: AsyncRequestProtocol, documentTypeId: int) -> Awaitable[ResponseEnvelope[List[DocumentSeries]]]: ...
+def Get(api: object, documentTypeId: int) -> ResponseEnvelope[List[DocumentSeries]] | Awaitable[ResponseEnvelope[List[DocumentSeries]]]:
+    params, data = _prepare_Get(documentTypeId=documentTypeId)
+    return invoke_operation(api, OP_Get, params=params, data=data)
+
+__all__ = ["Get"]

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IDocumentSeriesController/_common.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_Get = ('GET', '/api/DocumentSeries')
+def _prepare_Get(*, documentTypeId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentTypeId"] = documentTypeId
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IDocumentSeriesController/_ops.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import List
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels import DocumentSeries
+
+_ADAPTER_Get = TypeAdapter(List[DocumentSeries])
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[DocumentSeries]]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/DocumentSeries', parser=_parse_Get)

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IDocumentTypesController/__init__.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Awaitable, List, overload
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels import DocumentType
+from ._common import (
+    _prepare_Get,
+    _prepare_GetByCharacter,
+)
+from ._ops import (
+    OP_Get,
+    OP_GetByCharacter,
+)
+
+@overload
+def Get(api: SyncInvokerProtocol, id: int) -> ResponseEnvelope[DocumentType]: ...
+@overload
+def Get(api: SyncRequestProtocol, id: int) -> ResponseEnvelope[DocumentType]: ...
+@overload
+def Get(api: AsyncInvokerProtocol, id: int) -> Awaitable[ResponseEnvelope[DocumentType]]: ...
+@overload
+def Get(api: AsyncRequestProtocol, id: int) -> Awaitable[ResponseEnvelope[DocumentType]]: ...
+def Get(api: object, id: int) -> ResponseEnvelope[DocumentType] | Awaitable[ResponseEnvelope[DocumentType]]:
+    params, data = _prepare_Get(id=id)
+    return invoke_operation(api, OP_Get, params=params, data=data)
+
+@overload
+def GetByCharacter(api: SyncInvokerProtocol, documentCharacter: int) -> ResponseEnvelope[List[DocumentType]]: ...
+@overload
+def GetByCharacter(api: SyncRequestProtocol, documentCharacter: int) -> ResponseEnvelope[List[DocumentType]]: ...
+@overload
+def GetByCharacter(api: AsyncInvokerProtocol, documentCharacter: int) -> Awaitable[ResponseEnvelope[List[DocumentType]]]: ...
+@overload
+def GetByCharacter(api: AsyncRequestProtocol, documentCharacter: int) -> Awaitable[ResponseEnvelope[List[DocumentType]]]: ...
+def GetByCharacter(api: object, documentCharacter: int) -> ResponseEnvelope[List[DocumentType]] | Awaitable[ResponseEnvelope[List[DocumentType]]]:
+    params, data = _prepare_GetByCharacter(documentCharacter=documentCharacter)
+    return invoke_operation(api, OP_GetByCharacter, params=params, data=data)
+
+__all__ = ["Get", "GetByCharacter"]

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IDocumentTypesController/_common.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_Get = ('GET', '/api/DocumentTypes')
+def _prepare_Get(*, id) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    data = None
+    return params or None, data
+
+_REQUEST_GetByCharacter = ('GET', '/api/DocumentTypes')
+def _prepare_GetByCharacter(*, documentCharacter) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentCharacter"] = documentCharacter
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IDocumentTypesController/_ops.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import List
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels import DocumentType
+
+_ADAPTER_Get = TypeAdapter(DocumentType)
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[DocumentType]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/DocumentTypes', parser=_parse_Get)
+
+_ADAPTER_GetByCharacter = TypeAdapter(List[DocumentType])
+
+def _parse_GetByCharacter(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[DocumentType]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByCharacter)
+OP_GetByCharacter = OperationSpec(method='GET', path='/api/DocumentTypes', parser=_parse_GetByCharacter)

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IKsefController/__init__.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Any, Awaitable, overload
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from ._common import (
+    _prepare_AddSendToKsefEventAsync,
+    _prepare_ChangeKsefStatusAsync,
+)
+from ._ops import (
+    OP_AddSendToKsefEventAsync,
+    OP_ChangeKsefStatusAsync,
+)
+
+@overload
+def AddSendToKsefEventAsync(api: SyncInvokerProtocol, cancellationToken: int, docId: Any) -> ResponseEnvelope[None]: ...
+@overload
+def AddSendToKsefEventAsync(api: SyncRequestProtocol, cancellationToken: int, docId: Any) -> ResponseEnvelope[None]: ...
+@overload
+def AddSendToKsefEventAsync(api: AsyncInvokerProtocol, cancellationToken: int, docId: Any) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def AddSendToKsefEventAsync(api: AsyncRequestProtocol, cancellationToken: int, docId: Any) -> Awaitable[ResponseEnvelope[None]]: ...
+def AddSendToKsefEventAsync(api: object, cancellationToken: int, docId: Any) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_AddSendToKsefEventAsync(cancellationToken=cancellationToken, docId=docId)
+    return invoke_operation(api, OP_AddSendToKsefEventAsync, params=params, data=data)
+
+@overload
+def ChangeKsefStatusAsync(api: SyncInvokerProtocol, id: int, ksefStatus: int, cancellationToken: Any) -> ResponseEnvelope[None]: ...
+@overload
+def ChangeKsefStatusAsync(api: SyncRequestProtocol, id: int, ksefStatus: int, cancellationToken: Any) -> ResponseEnvelope[None]: ...
+@overload
+def ChangeKsefStatusAsync(api: AsyncInvokerProtocol, id: int, ksefStatus: int, cancellationToken: Any) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def ChangeKsefStatusAsync(api: AsyncRequestProtocol, id: int, ksefStatus: int, cancellationToken: Any) -> Awaitable[ResponseEnvelope[None]]: ...
+def ChangeKsefStatusAsync(api: object, id: int, ksefStatus: int, cancellationToken: Any) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_ChangeKsefStatusAsync(id=id, ksefStatus=ksefStatus, cancellationToken=cancellationToken)
+    return invoke_operation(api, OP_ChangeKsefStatusAsync, params=params, data=data)
+
+__all__ = ["AddSendToKsefEventAsync", "ChangeKsefStatusAsync"]

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IKsefController/_common.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_AddSendToKsefEventAsync = ('POST', '/api/Ksef/AddSendToKsefEvent')
+def _prepare_AddSendToKsefEventAsync(*, cancellationToken, docId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["cancellationToken"] = cancellationToken
+    params["docId"] = docId
+    data = None
+    return params or None, data
+
+_REQUEST_ChangeKsefStatusAsync = ('POST', '/api/Ksef/ChangeKsefStatusAsync')
+def _prepare_ChangeKsefStatusAsync(*, id, ksefStatus, cancellationToken) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    params["ksefStatus"] = ksefStatus
+    params["cancellationToken"] = cancellationToken
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IKsefController/_ops.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from typing import Any
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+
+def _parse_AddSendToKsefEventAsync(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_AddSendToKsefEventAsync = OperationSpec(method='POST', path='/api/Ksef/AddSendToKsefEvent', parser=_parse_AddSendToKsefEventAsync)
+
+def _parse_ChangeKsefStatusAsync(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_ChangeKsefStatusAsync = OperationSpec(method='POST', path='/api/Ksef/ChangeKsefStatusAsync', parser=_parse_ChangeKsefStatusAsync)

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IPaymentFormsController/__init__.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Awaitable, List, overload
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels import PaymentForm
+from ._common import (
+    _prepare_Get,
+)
+from ._ops import (
+    OP_Get,
+)
+
+@overload
+def Get(api: SyncInvokerProtocol, registryId: int) -> ResponseEnvelope[List[PaymentForm]]: ...
+@overload
+def Get(api: SyncRequestProtocol, registryId: int) -> ResponseEnvelope[List[PaymentForm]]: ...
+@overload
+def Get(api: AsyncInvokerProtocol, registryId: int) -> Awaitable[ResponseEnvelope[List[PaymentForm]]]: ...
+@overload
+def Get(api: AsyncRequestProtocol, registryId: int) -> Awaitable[ResponseEnvelope[List[PaymentForm]]]: ...
+def Get(api: object, registryId: int) -> ResponseEnvelope[List[PaymentForm]] | Awaitable[ResponseEnvelope[List[PaymentForm]]]:
+    params, data = _prepare_Get(registryId=registryId)
+    return invoke_operation(api, OP_Get, params=params, data=data)
+
+__all__ = ["Get"]

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IPaymentFormsController/_common.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_Get = ('GET', '/api/PaymentForms')
+def _prepare_Get(*, registryId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["registryId"] = registryId
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Common/Interfaces/IPaymentFormsController/_ops.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import List
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels import PaymentForm
+
+_ADAPTER_Get = TypeAdapter(List[PaymentForm])
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[PaymentForm]]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/PaymentForms', parser=_parse_Get)

SymfWebAPI/WebAPI/Interface/Common/Interfaces/__init__.py

@@ -0,0 +1,25 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("ICurrencyRatesController", "IDocumentSeriesController", "IDocumentTypesController", "IKsefController", "IPaymentFormsController",)
+
+def __getattr__(name: str):
+    if name in __all__:
+        module = importlib.import_module(f".{name}", __name__)
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+def __dir__():
+    return sorted(set(__all__) | {n for n in globals() if not n.startswith('_')})
+
+if TYPE_CHECKING:
+    from . import ICurrencyRatesController as _ICurrencyRatesController
+    from . import IDocumentSeriesController as _IDocumentSeriesController
+    from . import IDocumentTypesController as _IDocumentTypesController
+    from . import IKsefController as _IKsefController
+    from . import IPaymentFormsController as _IPaymentFormsController