SymfWebAPI 1.26.10.1__py3-none-any.whl

SymfWebAPI/WebAPI/Interface/FKF/Dimensions/__init__.py

@@ -0,0 +1,21 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("Interfaces",)
+
+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

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentAttachmentsController/__init__.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Awaitable, 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.Rdf import RdfDocumentAttachment
+from ._common import (
+    _prepare_AddNew,
+    _prepare_Update,
+)
+from ._ops import (
+    OP_AddNew,
+    OP_Update,
+)
+
+@overload
+def AddNew(api: SyncInvokerProtocol, documentId: int, yearId: int, newDocumentAttachment: "RdfDocumentAttachment") -> ResponseEnvelope[None]: ...
+@overload
+def AddNew(api: SyncRequestProtocol, documentId: int, yearId: int, newDocumentAttachment: "RdfDocumentAttachment") -> ResponseEnvelope[None]: ...
+@overload
+def AddNew(api: AsyncInvokerProtocol, documentId: int, yearId: int, newDocumentAttachment: "RdfDocumentAttachment") -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def AddNew(api: AsyncRequestProtocol, documentId: int, yearId: int, newDocumentAttachment: "RdfDocumentAttachment") -> Awaitable[ResponseEnvelope[None]]: ...
+def AddNew(api: object, documentId: int, yearId: int, newDocumentAttachment: "RdfDocumentAttachment") -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_AddNew(documentId=documentId, yearId=yearId, newDocumentAttachment=newDocumentAttachment)
+    return invoke_operation(api, OP_AddNew, params=params, data=data)
+
+@overload
+def Update(api: SyncInvokerProtocol, documentId: int, yearId: int, newDocumentAttachment: "RdfDocumentAttachment") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, documentId: int, yearId: int, newDocumentAttachment: "RdfDocumentAttachment") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: AsyncInvokerProtocol, documentId: int, yearId: int, newDocumentAttachment: "RdfDocumentAttachment") -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def Update(api: AsyncRequestProtocol, documentId: int, yearId: int, newDocumentAttachment: "RdfDocumentAttachment") -> Awaitable[ResponseEnvelope[None]]: ...
+def Update(api: object, documentId: int, yearId: int, newDocumentAttachment: "RdfDocumentAttachment") -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_Update(documentId=documentId, yearId=yearId, newDocumentAttachment=newDocumentAttachment)
+    return invoke_operation(api, OP_Update, params=params, data=data)
+
+__all__ = ["AddNew", "Update"]

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentAttachmentsController/_common.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_AddNew = ('POST', '/api/FKDocumentAttachments/AddNew')
+def _prepare_AddNew(*, documentId, yearId, newDocumentAttachment) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentId"] = documentId
+    params["yearId"] = yearId
+    data = newDocumentAttachment.model_dump_json(exclude_unset=True) if newDocumentAttachment is not None else None
+    return params or None, data
+
+_REQUEST_Update = ('PUT', '/api/FKDocumentAttachments/Update')
+def _prepare_Update(*, documentId, yearId, newDocumentAttachment) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentId"] = documentId
+    params["yearId"] = yearId
+    data = newDocumentAttachment.model_dump_json(exclude_unset=True) if newDocumentAttachment is not None else None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentAttachmentsController/_ops.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+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.Rdf import RdfDocumentAttachment
+
+def _parse_AddNew(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_AddNew = OperationSpec(method='POST', path='/api/FKDocumentAttachments/AddNew', parser=_parse_AddNew)
+
+def _parse_Update(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_Update = OperationSpec(method='PUT', path='/api/FKDocumentAttachments/Update', parser=_parse_Update)

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentLinksController/__init__.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Awaitable, 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.Rdf import RdfDocumentLink
+from ._common import (
+    _prepare_AddNew,
+    _prepare_Update,
+)
+from ._ops import (
+    OP_AddNew,
+    OP_Update,
+)
+
+@overload
+def AddNew(api: SyncInvokerProtocol, documentId: int, yearId: int, newDocumentLink: "RdfDocumentLink") -> ResponseEnvelope[None]: ...
+@overload
+def AddNew(api: SyncRequestProtocol, documentId: int, yearId: int, newDocumentLink: "RdfDocumentLink") -> ResponseEnvelope[None]: ...
+@overload
+def AddNew(api: AsyncInvokerProtocol, documentId: int, yearId: int, newDocumentLink: "RdfDocumentLink") -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def AddNew(api: AsyncRequestProtocol, documentId: int, yearId: int, newDocumentLink: "RdfDocumentLink") -> Awaitable[ResponseEnvelope[None]]: ...
+def AddNew(api: object, documentId: int, yearId: int, newDocumentLink: "RdfDocumentLink") -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_AddNew(documentId=documentId, yearId=yearId, newDocumentLink=newDocumentLink)
+    return invoke_operation(api, OP_AddNew, params=params, data=data)
+
+@overload
+def Update(api: SyncInvokerProtocol, documentId: int, yearId: int, newDocumentLink: "RdfDocumentLink") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, documentId: int, yearId: int, newDocumentLink: "RdfDocumentLink") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: AsyncInvokerProtocol, documentId: int, yearId: int, newDocumentLink: "RdfDocumentLink") -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def Update(api: AsyncRequestProtocol, documentId: int, yearId: int, newDocumentLink: "RdfDocumentLink") -> Awaitable[ResponseEnvelope[None]]: ...
+def Update(api: object, documentId: int, yearId: int, newDocumentLink: "RdfDocumentLink") -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_Update(documentId=documentId, yearId=yearId, newDocumentLink=newDocumentLink)
+    return invoke_operation(api, OP_Update, params=params, data=data)
+
+__all__ = ["AddNew", "Update"]

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentLinksController/_common.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_AddNew = ('POST', '/api/FKDocumentLinks/AddNew')
+def _prepare_AddNew(*, documentId, yearId, newDocumentLink) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentId"] = documentId
+    params["yearId"] = yearId
+    data = newDocumentLink.model_dump_json(exclude_unset=True) if newDocumentLink is not None else None
+    return params or None, data
+
+_REQUEST_Update = ('PUT', '/api/FKDocumentLinks/Update')
+def _prepare_Update(*, documentId, yearId, newDocumentLink) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentId"] = documentId
+    params["yearId"] = yearId
+    data = newDocumentLink.model_dump_json(exclude_unset=True) if newDocumentLink is not None else None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentLinksController/_ops.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+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.Rdf import RdfDocumentLink
+
+def _parse_AddNew(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_AddNew = OperationSpec(method='POST', path='/api/FKDocumentLinks/AddNew', parser=_parse_AddNew)
+
+def _parse_Update(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_Update = OperationSpec(method='PUT', path='/api/FKDocumentLinks/Update', parser=_parse_Update)

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentsBusinessIssueController/__init__.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import Awaitable, 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.Issue.Business import BusinessDocumentIssue
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels.V2026_1 import Document
+from ._common import (
+    _prepare_NewPurchaseInvoice,
+    _prepare_NewPurchaseInvoiceCorrection,
+    _prepare_NewSaleInvoice,
+    _prepare_NewSaleInvoiceCorrection,
+)
+from ._ops import (
+    OP_NewPurchaseInvoice,
+    OP_NewPurchaseInvoiceCorrection,
+    OP_NewSaleInvoice,
+    OP_NewSaleInvoiceCorrection,
+)
+
+@overload
+def NewPurchaseInvoice(api: SyncInvokerProtocol, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document]: ...
+@overload
+def NewPurchaseInvoice(api: SyncRequestProtocol, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document]: ...
+@overload
+def NewPurchaseInvoice(api: AsyncInvokerProtocol, documentIssue: "BusinessDocumentIssue") -> Awaitable[ResponseEnvelope[Document]]: ...
+@overload
+def NewPurchaseInvoice(api: AsyncRequestProtocol, documentIssue: "BusinessDocumentIssue") -> Awaitable[ResponseEnvelope[Document]]: ...
+def NewPurchaseInvoice(api: object, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document] | Awaitable[ResponseEnvelope[Document]]:
+    params, data = _prepare_NewPurchaseInvoice(documentIssue=documentIssue)
+    return invoke_operation(api, OP_NewPurchaseInvoice, params=params, data=data)
+
+@overload
+def NewPurchaseInvoiceCorrection(api: SyncInvokerProtocol, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document]: ...
+@overload
+def NewPurchaseInvoiceCorrection(api: SyncRequestProtocol, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document]: ...
+@overload
+def NewPurchaseInvoiceCorrection(api: AsyncInvokerProtocol, documentIssue: "BusinessDocumentIssue") -> Awaitable[ResponseEnvelope[Document]]: ...
+@overload
+def NewPurchaseInvoiceCorrection(api: AsyncRequestProtocol, documentIssue: "BusinessDocumentIssue") -> Awaitable[ResponseEnvelope[Document]]: ...
+def NewPurchaseInvoiceCorrection(api: object, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document] | Awaitable[ResponseEnvelope[Document]]:
+    params, data = _prepare_NewPurchaseInvoiceCorrection(documentIssue=documentIssue)
+    return invoke_operation(api, OP_NewPurchaseInvoiceCorrection, params=params, data=data)
+
+@overload
+def NewSaleInvoice(api: SyncInvokerProtocol, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document]: ...
+@overload
+def NewSaleInvoice(api: SyncRequestProtocol, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document]: ...
+@overload
+def NewSaleInvoice(api: AsyncInvokerProtocol, documentIssue: "BusinessDocumentIssue") -> Awaitable[ResponseEnvelope[Document]]: ...
+@overload
+def NewSaleInvoice(api: AsyncRequestProtocol, documentIssue: "BusinessDocumentIssue") -> Awaitable[ResponseEnvelope[Document]]: ...
+def NewSaleInvoice(api: object, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document] | Awaitable[ResponseEnvelope[Document]]:
+    params, data = _prepare_NewSaleInvoice(documentIssue=documentIssue)
+    return invoke_operation(api, OP_NewSaleInvoice, params=params, data=data)
+
+@overload
+def NewSaleInvoiceCorrection(api: SyncInvokerProtocol, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document]: ...
+@overload
+def NewSaleInvoiceCorrection(api: SyncRequestProtocol, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document]: ...
+@overload
+def NewSaleInvoiceCorrection(api: AsyncInvokerProtocol, documentIssue: "BusinessDocumentIssue") -> Awaitable[ResponseEnvelope[Document]]: ...
+@overload
+def NewSaleInvoiceCorrection(api: AsyncRequestProtocol, documentIssue: "BusinessDocumentIssue") -> Awaitable[ResponseEnvelope[Document]]: ...
+def NewSaleInvoiceCorrection(api: object, documentIssue: "BusinessDocumentIssue") -> ResponseEnvelope[Document] | Awaitable[ResponseEnvelope[Document]]:
+    params, data = _prepare_NewSaleInvoiceCorrection(documentIssue=documentIssue)
+    return invoke_operation(api, OP_NewSaleInvoiceCorrection, params=params, data=data)
+
+__all__ = ["NewPurchaseInvoice", "NewPurchaseInvoiceCorrection", "NewSaleInvoice", "NewSaleInvoiceCorrection"]

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentsBusinessIssueController/_common.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_NewPurchaseInvoice = ('POST', '/api/FKDocumentsBusinessIssue/NewPurchaseInvoice')
+def _prepare_NewPurchaseInvoice(*, documentIssue) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = documentIssue.model_dump_json(exclude_unset=True) if documentIssue is not None else None
+    return params or None, data
+
+_REQUEST_NewPurchaseInvoiceCorrection = ('POST', '/api/FKDocumentsBusinessIssue/NewPurchaseInvoiceCorrection')
+def _prepare_NewPurchaseInvoiceCorrection(*, documentIssue) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = documentIssue.model_dump_json(exclude_unset=True) if documentIssue is not None else None
+    return params or None, data
+
+_REQUEST_NewSaleInvoice = ('POST', '/api/FKDocumentsBusinessIssue/NewSaleInvoice')
+def _prepare_NewSaleInvoice(*, documentIssue) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = documentIssue.model_dump_json(exclude_unset=True) if documentIssue is not None else None
+    return params or None, data
+
+_REQUEST_NewSaleInvoiceCorrection = ('POST', '/api/FKDocumentsBusinessIssue/NewSaleInvoiceCorrection')
+def _prepare_NewSaleInvoiceCorrection(*, documentIssue) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = documentIssue.model_dump_json(exclude_unset=True) if documentIssue is not None else None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentsBusinessIssueController/_ops.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+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.Issue.Business import BusinessDocumentIssue
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels.V2026_1 import Document
+
+_ADAPTER_NewPurchaseInvoice = TypeAdapter(Document)
+
+def _parse_NewPurchaseInvoice(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Document]:
+    return parse_with_adapter(envelope, _ADAPTER_NewPurchaseInvoice)
+OP_NewPurchaseInvoice = OperationSpec(method='POST', path='/api/FKDocumentsBusinessIssue/NewPurchaseInvoice', parser=_parse_NewPurchaseInvoice)
+
+_ADAPTER_NewPurchaseInvoiceCorrection = TypeAdapter(Document)
+
+def _parse_NewPurchaseInvoiceCorrection(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Document]:
+    return parse_with_adapter(envelope, _ADAPTER_NewPurchaseInvoiceCorrection)
+OP_NewPurchaseInvoiceCorrection = OperationSpec(method='POST', path='/api/FKDocumentsBusinessIssue/NewPurchaseInvoiceCorrection', parser=_parse_NewPurchaseInvoiceCorrection)
+
+_ADAPTER_NewSaleInvoice = TypeAdapter(Document)
+
+def _parse_NewSaleInvoice(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Document]:
+    return parse_with_adapter(envelope, _ADAPTER_NewSaleInvoice)
+OP_NewSaleInvoice = OperationSpec(method='POST', path='/api/FKDocumentsBusinessIssue/NewSaleInvoice', parser=_parse_NewSaleInvoice)
+
+_ADAPTER_NewSaleInvoiceCorrection = TypeAdapter(Document)
+
+def _parse_NewSaleInvoiceCorrection(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Document]:
+    return parse_with_adapter(envelope, _ADAPTER_NewSaleInvoiceCorrection)
+OP_NewSaleInvoiceCorrection = OperationSpec(method='POST', path='/api/FKDocumentsBusinessIssue/NewSaleInvoiceCorrection', parser=_parse_NewSaleInvoiceCorrection)

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentsController/__init__.py

@@ -0,0 +1,161 @@
+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.FKF.Documents.ViewModels.V2026_1 import Document
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels import DocumentListElement
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels import DocumentType
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels import DocumentV2
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels import Feature
+from SymfWebAPI.WebAPI.Interface.ViewModels import Page
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels.Transactions import TransactionDocument
+from SymfWebAPI.WebAPI.Interface.Enums import enumOrderByType
+from ._common import (
+    _prepare_Get,
+    _prepare_GetV2,
+    _prepare_GetFromBuffer,
+    _prepare_GetFromAccountingBooks,
+    _prepare_GetFromSchemes,
+    _prepare_GetDocumentFeatures,
+    _prepare_GetDocumentRecordFeatures,
+    _prepare_GetDocumentTypes,
+    _prepare_GetPagedDocument,
+    _prepare_GetDocumentTransactions,
+)
+from ._ops import (
+    OP_Get,
+    OP_GetV2,
+    OP_GetFromBuffer,
+    OP_GetFromAccountingBooks,
+    OP_GetFromSchemes,
+    OP_GetDocumentFeatures,
+    OP_GetDocumentRecordFeatures,
+    OP_GetDocumentTypes,
+    OP_GetPagedDocument,
+    OP_GetDocumentTransactions,
+)
+
+@overload
+def Get(api: SyncInvokerProtocol, id: int, yearId: int) -> ResponseEnvelope[Document]: ...
+@overload
+def Get(api: SyncRequestProtocol, id: int, yearId: int) -> ResponseEnvelope[Document]: ...
+@overload
+def Get(api: AsyncInvokerProtocol, id: int, yearId: int) -> Awaitable[ResponseEnvelope[Document]]: ...
+@overload
+def Get(api: AsyncRequestProtocol, id: int, yearId: int) -> Awaitable[ResponseEnvelope[Document]]: ...
+def Get(api: object, id: int, yearId: int) -> ResponseEnvelope[Document] | Awaitable[ResponseEnvelope[Document]]:
+    params, data = _prepare_Get(id=id, yearId=yearId)
+    return invoke_operation(api, OP_Get, params=params, data=data)
+
+@overload
+def GetV2(api: SyncInvokerProtocol, id: int, yearId: int) -> ResponseEnvelope[DocumentV2]: ...
+@overload
+def GetV2(api: SyncRequestProtocol, id: int, yearId: int) -> ResponseEnvelope[DocumentV2]: ...
+@overload
+def GetV2(api: AsyncInvokerProtocol, id: int, yearId: int) -> Awaitable[ResponseEnvelope[DocumentV2]]: ...
+@overload
+def GetV2(api: AsyncRequestProtocol, id: int, yearId: int) -> Awaitable[ResponseEnvelope[DocumentV2]]: ...
+def GetV2(api: object, id: int, yearId: int) -> ResponseEnvelope[DocumentV2] | Awaitable[ResponseEnvelope[DocumentV2]]:
+    params, data = _prepare_GetV2(id=id, yearId=yearId)
+    return invoke_operation(api, OP_GetV2, params=params, data=data)
+
+@overload
+def GetFromBuffer(api: SyncInvokerProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[DocumentListElement]]: ...
+@overload
+def GetFromBuffer(api: SyncRequestProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[DocumentListElement]]: ...
+@overload
+def GetFromBuffer(api: AsyncInvokerProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[DocumentListElement]]]: ...
+@overload
+def GetFromBuffer(api: AsyncRequestProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[DocumentListElement]]]: ...
+def GetFromBuffer(api: object, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[DocumentListElement]] | Awaitable[ResponseEnvelope[List[DocumentListElement]]]:
+    params, data = _prepare_GetFromBuffer(yearId=yearId, contractorPosition=contractorPosition, dateFrom=dateFrom, dateTo=dateTo)
+    return invoke_operation(api, OP_GetFromBuffer, params=params, data=data)
+
+@overload
+def GetFromAccountingBooks(api: SyncInvokerProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[DocumentListElement]]: ...
+@overload
+def GetFromAccountingBooks(api: SyncRequestProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[DocumentListElement]]: ...
+@overload
+def GetFromAccountingBooks(api: AsyncInvokerProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[DocumentListElement]]]: ...
+@overload
+def GetFromAccountingBooks(api: AsyncRequestProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[DocumentListElement]]]: ...
+def GetFromAccountingBooks(api: object, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[DocumentListElement]] | Awaitable[ResponseEnvelope[List[DocumentListElement]]]:
+    params, data = _prepare_GetFromAccountingBooks(yearId=yearId, contractorPosition=contractorPosition, dateFrom=dateFrom, dateTo=dateTo)
+    return invoke_operation(api, OP_GetFromAccountingBooks, params=params, data=data)
+
+@overload
+def GetFromSchemes(api: SyncInvokerProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[DocumentListElement]]: ...
+@overload
+def GetFromSchemes(api: SyncRequestProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[DocumentListElement]]: ...
+@overload
+def GetFromSchemes(api: AsyncInvokerProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[DocumentListElement]]]: ...
+@overload
+def GetFromSchemes(api: AsyncRequestProtocol, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> Awaitable[ResponseEnvelope[List[DocumentListElement]]]: ...
+def GetFromSchemes(api: object, yearId: int, contractorPosition: int, dateFrom: Optional[datetime] = None, dateTo: Optional[datetime] = None) -> ResponseEnvelope[List[DocumentListElement]] | Awaitable[ResponseEnvelope[List[DocumentListElement]]]:
+    params, data = _prepare_GetFromSchemes(yearId=yearId, contractorPosition=contractorPosition, dateFrom=dateFrom, dateTo=dateTo)
+    return invoke_operation(api, OP_GetFromSchemes, params=params, data=data)
+
+@overload
+def GetDocumentFeatures(api: SyncInvokerProtocol, yearId: int) -> ResponseEnvelope[List[Feature]]: ...
+@overload
+def GetDocumentFeatures(api: SyncRequestProtocol, yearId: int) -> ResponseEnvelope[List[Feature]]: ...
+@overload
+def GetDocumentFeatures(api: AsyncInvokerProtocol, yearId: int) -> Awaitable[ResponseEnvelope[List[Feature]]]: ...
+@overload
+def GetDocumentFeatures(api: AsyncRequestProtocol, yearId: int) -> Awaitable[ResponseEnvelope[List[Feature]]]: ...
+def GetDocumentFeatures(api: object, yearId: int) -> ResponseEnvelope[List[Feature]] | Awaitable[ResponseEnvelope[List[Feature]]]:
+    params, data = _prepare_GetDocumentFeatures(yearId=yearId)
+    return invoke_operation(api, OP_GetDocumentFeatures, params=params, data=data)
+
+@overload
+def GetDocumentRecordFeatures(api: SyncInvokerProtocol, yearId: int) -> ResponseEnvelope[List[Feature]]: ...
+@overload
+def GetDocumentRecordFeatures(api: SyncRequestProtocol, yearId: int) -> ResponseEnvelope[List[Feature]]: ...
+@overload
+def GetDocumentRecordFeatures(api: AsyncInvokerProtocol, yearId: int) -> Awaitable[ResponseEnvelope[List[Feature]]]: ...
+@overload
+def GetDocumentRecordFeatures(api: AsyncRequestProtocol, yearId: int) -> Awaitable[ResponseEnvelope[List[Feature]]]: ...
+def GetDocumentRecordFeatures(api: object, yearId: int) -> ResponseEnvelope[List[Feature]] | Awaitable[ResponseEnvelope[List[Feature]]]:
+    params, data = _prepare_GetDocumentRecordFeatures(yearId=yearId)
+    return invoke_operation(api, OP_GetDocumentRecordFeatures, params=params, data=data)
+
+@overload
+def GetDocumentTypes(api: SyncInvokerProtocol, yearId: int) -> ResponseEnvelope[List[DocumentType]]: ...
+@overload
+def GetDocumentTypes(api: SyncRequestProtocol, yearId: int) -> ResponseEnvelope[List[DocumentType]]: ...
+@overload
+def GetDocumentTypes(api: AsyncInvokerProtocol, yearId: int) -> Awaitable[ResponseEnvelope[List[DocumentType]]]: ...
+@overload
+def GetDocumentTypes(api: AsyncRequestProtocol, yearId: int) -> Awaitable[ResponseEnvelope[List[DocumentType]]]: ...
+def GetDocumentTypes(api: object, yearId: int) -> ResponseEnvelope[List[DocumentType]] | Awaitable[ResponseEnvelope[List[DocumentType]]]:
+    params, data = _prepare_GetDocumentTypes(yearId=yearId)
+    return invoke_operation(api, OP_GetDocumentTypes, params=params, data=data)
+
+@overload
+def GetPagedDocument(api: SyncInvokerProtocol, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page]: ...
+@overload
+def GetPagedDocument(api: SyncRequestProtocol, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page]: ...
+@overload
+def GetPagedDocument(api: AsyncInvokerProtocol, page: int, size: int, orderBy: "enumOrderByType") -> Awaitable[ResponseEnvelope[Page]]: ...
+@overload
+def GetPagedDocument(api: AsyncRequestProtocol, page: int, size: int, orderBy: "enumOrderByType") -> Awaitable[ResponseEnvelope[Page]]: ...
+def GetPagedDocument(api: object, page: int, size: int, orderBy: "enumOrderByType") -> ResponseEnvelope[Page] | Awaitable[ResponseEnvelope[Page]]:
+    params, data = _prepare_GetPagedDocument(page=page, size=size, orderBy=orderBy)
+    return invoke_operation(api, OP_GetPagedDocument, params=params, data=data)
+
+@overload
+def GetDocumentTransactions(api: SyncInvokerProtocol) -> ResponseEnvelope[List[TransactionDocument]]: ...
+@overload
+def GetDocumentTransactions(api: SyncRequestProtocol) -> ResponseEnvelope[List[TransactionDocument]]: ...
+@overload
+def GetDocumentTransactions(api: AsyncInvokerProtocol) -> Awaitable[ResponseEnvelope[List[TransactionDocument]]]: ...
+@overload
+def GetDocumentTransactions(api: AsyncRequestProtocol) -> Awaitable[ResponseEnvelope[List[TransactionDocument]]]: ...
+def GetDocumentTransactions(api: object) -> ResponseEnvelope[List[TransactionDocument]] | Awaitable[ResponseEnvelope[List[TransactionDocument]]]:
+    params, data = _prepare_GetDocumentTransactions()
+    return invoke_operation(api, OP_GetDocumentTransactions, params=params, data=data)
+
+__all__ = ["Get", "GetV2", "GetFromBuffer", "GetFromAccountingBooks", "GetFromSchemes", "GetDocumentFeatures", "GetDocumentRecordFeatures", "GetDocumentTypes", "GetPagedDocument", "GetDocumentTransactions"]

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentsController/_common.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_Get = ('GET', '/api/FKDocuments')
+def _prepare_Get(*, id, yearId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    params["yearId"] = yearId
+    data = None
+    return params or None, data
+
+_REQUEST_GetV2 = ('GET', '/api/FKDocuments')
+def _prepare_GetV2(*, id, yearId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    params["yearId"] = yearId
+    data = None
+    return params or None, data
+
+_REQUEST_GetFromBuffer = ('GET', '/api/FKDocuments/Buffer')
+def _prepare_GetFromBuffer(*, yearId, contractorPosition, dateFrom = None, dateTo = None) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["yearId"] = yearId
+    params["contractorPosition"] = contractorPosition
+    if dateFrom is not None:
+        params["dateFrom"] = dateFrom
+    if dateTo is not None:
+        params["dateTo"] = dateTo
+    data = None
+    return params or None, data
+
+_REQUEST_GetFromAccountingBooks = ('GET', '/api/FKDocuments/Buffer')
+def _prepare_GetFromAccountingBooks(*, yearId, contractorPosition, dateFrom = None, dateTo = None) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["yearId"] = yearId
+    params["contractorPosition"] = contractorPosition
+    if dateFrom is not None:
+        params["dateFrom"] = dateFrom
+    if dateTo is not None:
+        params["dateTo"] = dateTo
+    data = None
+    return params or None, data
+
+_REQUEST_GetFromSchemes = ('GET', '/api/FKDocuments/Buffer')
+def _prepare_GetFromSchemes(*, yearId, contractorPosition, dateFrom = None, dateTo = None) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["yearId"] = yearId
+    params["contractorPosition"] = contractorPosition
+    if dateFrom is not None:
+        params["dateFrom"] = dateFrom
+    if dateTo is not None:
+        params["dateTo"] = dateTo
+    data = None
+    return params or None, data
+
+_REQUEST_GetDocumentFeatures = ('GET', '/api/FKDocuments/DocumentFeatures')
+def _prepare_GetDocumentFeatures(*, yearId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["yearId"] = yearId
+    data = None
+    return params or None, data
+
+_REQUEST_GetDocumentRecordFeatures = ('GET', '/api/FKDocuments/DocumentRecordFeatures')
+def _prepare_GetDocumentRecordFeatures(*, yearId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["yearId"] = yearId
+    data = None
+    return params or None, data
+
+_REQUEST_GetDocumentTypes = ('GET', '/api/FKDocuments/DocumentTypes')
+def _prepare_GetDocumentTypes(*, yearId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["yearId"] = yearId
+    data = None
+    return params or None, data
+
+_REQUEST_GetPagedDocument = ('GET', '/api/FKDocuments/Page')
+def _prepare_GetPagedDocument(*, page, size, orderBy) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["page"] = page
+    params["size"] = size
+    params["orderBy"] = orderBy.value
+    data = None
+    return params or None, data
+
+_REQUEST_GetDocumentTransactions = ('GET', '/api/FKDocuments/Transactions')
+def _prepare_GetDocumentTransactions() -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/FKF/Documents/Interfaces/IFKDocumentsController/_ops.py

@@ -0,0 +1,75 @@
+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.FKF.Documents.ViewModels.V2026_1 import Document
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels import DocumentListElement
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels import DocumentType
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels import DocumentV2
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels import Feature
+from SymfWebAPI.WebAPI.Interface.ViewModels import Page
+from SymfWebAPI.WebAPI.Interface.FKF.Documents.ViewModels.Transactions import TransactionDocument
+from SymfWebAPI.WebAPI.Interface.Enums import enumOrderByType
+
+_ADAPTER_Get = TypeAdapter(Document)
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Document]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/FKDocuments', parser=_parse_Get)
+
+_ADAPTER_GetV2 = TypeAdapter(DocumentV2)
+
+def _parse_GetV2(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[DocumentV2]:
+    return parse_with_adapter(envelope, _ADAPTER_GetV2)
+OP_GetV2 = OperationSpec(method='GET', path='/api/FKDocuments', parser=_parse_GetV2)
+
+_ADAPTER_GetFromBuffer = TypeAdapter(List[DocumentListElement])
+
+def _parse_GetFromBuffer(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[DocumentListElement]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetFromBuffer)
+OP_GetFromBuffer = OperationSpec(method='GET', path='/api/FKDocuments/Buffer', parser=_parse_GetFromBuffer)
+
+_ADAPTER_GetFromAccountingBooks = TypeAdapter(List[DocumentListElement])
+
+def _parse_GetFromAccountingBooks(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[DocumentListElement]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetFromAccountingBooks)
+OP_GetFromAccountingBooks = OperationSpec(method='GET', path='/api/FKDocuments/Buffer', parser=_parse_GetFromAccountingBooks)
+
+_ADAPTER_GetFromSchemes = TypeAdapter(List[DocumentListElement])
+
+def _parse_GetFromSchemes(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[DocumentListElement]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetFromSchemes)
+OP_GetFromSchemes = OperationSpec(method='GET', path='/api/FKDocuments/Buffer', parser=_parse_GetFromSchemes)
+
+_ADAPTER_GetDocumentFeatures = TypeAdapter(List[Feature])
+
+def _parse_GetDocumentFeatures(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[Feature]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetDocumentFeatures)
+OP_GetDocumentFeatures = OperationSpec(method='GET', path='/api/FKDocuments/DocumentFeatures', parser=_parse_GetDocumentFeatures)
+
+_ADAPTER_GetDocumentRecordFeatures = TypeAdapter(List[Feature])
+
+def _parse_GetDocumentRecordFeatures(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[Feature]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetDocumentRecordFeatures)
+OP_GetDocumentRecordFeatures = OperationSpec(method='GET', path='/api/FKDocuments/DocumentRecordFeatures', parser=_parse_GetDocumentRecordFeatures)
+
+_ADAPTER_GetDocumentTypes = TypeAdapter(List[DocumentType])
+
+def _parse_GetDocumentTypes(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[DocumentType]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetDocumentTypes)
+OP_GetDocumentTypes = OperationSpec(method='GET', path='/api/FKDocuments/DocumentTypes', parser=_parse_GetDocumentTypes)
+
+_ADAPTER_GetPagedDocument = TypeAdapter(Page)
+
+def _parse_GetPagedDocument(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Page]:
+    return parse_with_adapter(envelope, _ADAPTER_GetPagedDocument)
+OP_GetPagedDocument = OperationSpec(method='GET', path='/api/FKDocuments/Page', parser=_parse_GetPagedDocument)
+
+_ADAPTER_GetDocumentTransactions = TypeAdapter(List[TransactionDocument])
+
+def _parse_GetDocumentTransactions(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[TransactionDocument]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetDocumentTransactions)
+OP_GetDocumentTransactions = OperationSpec(method='GET', path='/api/FKDocuments/Transactions', parser=_parse_GetDocumentTransactions)