SymfWebAPI 1.26.10.1__py3-none-any.whl

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssProductController/_ops.py

@@ -0,0 +1,24 @@
+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.OSS.ViewModels import CountryProductList
+
+_ADAPTER_GetByCountry = TypeAdapter(CountryProductList)
+
+def _parse_GetByCountry(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[CountryProductList]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByCountry)
+OP_GetByCountry = OperationSpec(method='GET', path='/api/OssProduct', parser=_parse_GetByCountry)
+
+_ADAPTER_GetByErpProduct = TypeAdapter(CountryProductList)
+
+def _parse_GetByErpProduct(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[CountryProductList]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByErpProduct)
+OP_GetByErpProduct = OperationSpec(method='GET', path='/api/OssProduct', parser=_parse_GetByErpProduct)
+
+_ADAPTER_GetByShopProduct = TypeAdapter(CountryProductList)
+
+def _parse_GetByShopProduct(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[CountryProductList]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByShopProduct)
+OP_GetByShopProduct = OperationSpec(method='GET', path='/api/OssProduct', parser=_parse_GetByShopProduct)

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssProductMapsController/__init__.py

@@ -0,0 +1,84 @@
+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.OSS.ViewModels import ProductMap
+from SymfWebAPI.WebAPI.Interface.OSS.ViewModels import ProductMapCreate
+from ._common import (
+    _prepare_Create,
+    _prepare_Delete,
+    _prepare_GetByCountry,
+    _prepare_GetByErpProduct,
+    _prepare_GetByShopProduct,
+)
+from ._ops import (
+    OP_Create,
+    OP_Delete,
+    OP_GetByCountry,
+    OP_GetByErpProduct,
+    OP_GetByShopProduct,
+)
+
+@overload
+def Create(api: SyncInvokerProtocol, map: "ProductMapCreate") -> ResponseEnvelope[ProductMap]: ...
+@overload
+def Create(api: SyncRequestProtocol, map: "ProductMapCreate") -> ResponseEnvelope[ProductMap]: ...
+@overload
+def Create(api: AsyncInvokerProtocol, map: "ProductMapCreate") -> Awaitable[ResponseEnvelope[ProductMap]]: ...
+@overload
+def Create(api: AsyncRequestProtocol, map: "ProductMapCreate") -> Awaitable[ResponseEnvelope[ProductMap]]: ...
+def Create(api: object, map: "ProductMapCreate") -> ResponseEnvelope[ProductMap] | Awaitable[ResponseEnvelope[ProductMap]]:
+    params, data = _prepare_Create(map=map)
+    return invoke_operation(api, OP_Create, params=params, data=data)
+
+@overload
+def Delete(api: SyncInvokerProtocol, id: int) -> ResponseEnvelope[None]: ...
+@overload
+def Delete(api: SyncRequestProtocol, id: int) -> ResponseEnvelope[None]: ...
+@overload
+def Delete(api: AsyncInvokerProtocol, id: int) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def Delete(api: AsyncRequestProtocol, id: int) -> Awaitable[ResponseEnvelope[None]]: ...
+def Delete(api: object, id: int) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_Delete(id=id)
+    return invoke_operation(api, OP_Delete, params=params, data=data)
+
+@overload
+def GetByCountry(api: SyncInvokerProtocol, countryId: int) -> ResponseEnvelope[List[ProductMap]]: ...
+@overload
+def GetByCountry(api: SyncRequestProtocol, countryId: int) -> ResponseEnvelope[List[ProductMap]]: ...
+@overload
+def GetByCountry(api: AsyncInvokerProtocol, countryId: int) -> Awaitable[ResponseEnvelope[List[ProductMap]]]: ...
+@overload
+def GetByCountry(api: AsyncRequestProtocol, countryId: int) -> Awaitable[ResponseEnvelope[List[ProductMap]]]: ...
+def GetByCountry(api: object, countryId: int) -> ResponseEnvelope[List[ProductMap]] | Awaitable[ResponseEnvelope[List[ProductMap]]]:
+    params, data = _prepare_GetByCountry(countryId=countryId)
+    return invoke_operation(api, OP_GetByCountry, params=params, data=data)
+
+@overload
+def GetByErpProduct(api: SyncInvokerProtocol, erpProductId: int) -> ResponseEnvelope[List[ProductMap]]: ...
+@overload
+def GetByErpProduct(api: SyncRequestProtocol, erpProductId: int) -> ResponseEnvelope[List[ProductMap]]: ...
+@overload
+def GetByErpProduct(api: AsyncInvokerProtocol, erpProductId: int) -> Awaitable[ResponseEnvelope[List[ProductMap]]]: ...
+@overload
+def GetByErpProduct(api: AsyncRequestProtocol, erpProductId: int) -> Awaitable[ResponseEnvelope[List[ProductMap]]]: ...
+def GetByErpProduct(api: object, erpProductId: int) -> ResponseEnvelope[List[ProductMap]] | Awaitable[ResponseEnvelope[List[ProductMap]]]:
+    params, data = _prepare_GetByErpProduct(erpProductId=erpProductId)
+    return invoke_operation(api, OP_GetByErpProduct, params=params, data=data)
+
+@overload
+def GetByShopProduct(api: SyncInvokerProtocol, shopProductId: str) -> ResponseEnvelope[List[ProductMap]]: ...
+@overload
+def GetByShopProduct(api: SyncRequestProtocol, shopProductId: str) -> ResponseEnvelope[List[ProductMap]]: ...
+@overload
+def GetByShopProduct(api: AsyncInvokerProtocol, shopProductId: str) -> Awaitable[ResponseEnvelope[List[ProductMap]]]: ...
+@overload
+def GetByShopProduct(api: AsyncRequestProtocol, shopProductId: str) -> Awaitable[ResponseEnvelope[List[ProductMap]]]: ...
+def GetByShopProduct(api: object, shopProductId: str) -> ResponseEnvelope[List[ProductMap]] | Awaitable[ResponseEnvelope[List[ProductMap]]]:
+    params, data = _prepare_GetByShopProduct(shopProductId=shopProductId)
+    return invoke_operation(api, OP_GetByShopProduct, params=params, data=data)
+
+__all__ = ["Create", "Delete", "GetByCountry", "GetByErpProduct", "GetByShopProduct"]

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssProductMapsController/_common.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_Create = ('POST', '/api/OssProductMap/Create')
+def _prepare_Create(*, map) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = map.model_dump_json(exclude_unset=True) if map is not None else None
+    return params or None, data
+
+_REQUEST_Delete = ('DELETE', '/api/OssProductMap/Delete')
+def _prepare_Delete(*, id) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    data = None
+    return params or None, data
+
+_REQUEST_GetByCountry = ('GET', '/api/OssProductMap')
+def _prepare_GetByCountry(*, countryId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["countryId"] = countryId
+    data = None
+    return params or None, data
+
+_REQUEST_GetByErpProduct = ('GET', '/api/OssProductMap')
+def _prepare_GetByErpProduct(*, erpProductId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["erpProductId"] = erpProductId
+    data = None
+    return params or None, data
+
+_REQUEST_GetByShopProduct = ('GET', '/api/OssProductMap')
+def _prepare_GetByShopProduct(*, shopProductId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["shopProductId"] = shopProductId
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssProductMapsController/_ops.py

@@ -0,0 +1,36 @@
+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.OSS.ViewModels import ProductMap
+from SymfWebAPI.WebAPI.Interface.OSS.ViewModels import ProductMapCreate
+
+_ADAPTER_Create = TypeAdapter(ProductMap)
+
+def _parse_Create(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[ProductMap]:
+    return parse_with_adapter(envelope, _ADAPTER_Create)
+OP_Create = OperationSpec(method='POST', path='/api/OssProductMap/Create', parser=_parse_Create)
+
+def _parse_Delete(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_Delete = OperationSpec(method='DELETE', path='/api/OssProductMap/Delete', parser=_parse_Delete)
+
+_ADAPTER_GetByCountry = TypeAdapter(List[ProductMap])
+
+def _parse_GetByCountry(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductMap]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByCountry)
+OP_GetByCountry = OperationSpec(method='GET', path='/api/OssProductMap', parser=_parse_GetByCountry)
+
+_ADAPTER_GetByErpProduct = TypeAdapter(List[ProductMap])
+
+def _parse_GetByErpProduct(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductMap]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByErpProduct)
+OP_GetByErpProduct = OperationSpec(method='GET', path='/api/OssProductMap', parser=_parse_GetByErpProduct)
+
+_ADAPTER_GetByShopProduct = TypeAdapter(List[ProductMap])
+
+def _parse_GetByShopProduct(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[ProductMap]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByShopProduct)
+OP_GetByShopProduct = OperationSpec(method='GET', path='/api/OssProductMap', parser=_parse_GetByShopProduct)

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssReportsController/__init__.py

@@ -0,0 +1,55 @@
+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.Common.ViewModels import PDF
+from ._common import (
+    _prepare_GetOrderPDF,
+    _prepare_GetSaleDocumentPDF,
+    _prepare_GetWarehouseDocumentPDF,
+)
+from ._ops import (
+    OP_GetOrderPDF,
+    OP_GetSaleDocumentPDF,
+    OP_GetWarehouseDocumentPDF,
+)
+
+@overload
+def GetOrderPDF(api: SyncInvokerProtocol, orderId: int) -> ResponseEnvelope[PDF]: ...
+@overload
+def GetOrderPDF(api: SyncRequestProtocol, orderId: int) -> ResponseEnvelope[PDF]: ...
+@overload
+def GetOrderPDF(api: AsyncInvokerProtocol, orderId: int) -> Awaitable[ResponseEnvelope[PDF]]: ...
+@overload
+def GetOrderPDF(api: AsyncRequestProtocol, orderId: int) -> Awaitable[ResponseEnvelope[PDF]]: ...
+def GetOrderPDF(api: object, orderId: int) -> ResponseEnvelope[PDF] | Awaitable[ResponseEnvelope[PDF]]:
+    params, data = _prepare_GetOrderPDF(orderId=orderId)
+    return invoke_operation(api, OP_GetOrderPDF, params=params, data=data)
+
+@overload
+def GetSaleDocumentPDF(api: SyncInvokerProtocol, documentId: int) -> ResponseEnvelope[PDF]: ...
+@overload
+def GetSaleDocumentPDF(api: SyncRequestProtocol, documentId: int) -> ResponseEnvelope[PDF]: ...
+@overload
+def GetSaleDocumentPDF(api: AsyncInvokerProtocol, documentId: int) -> Awaitable[ResponseEnvelope[PDF]]: ...
+@overload
+def GetSaleDocumentPDF(api: AsyncRequestProtocol, documentId: int) -> Awaitable[ResponseEnvelope[PDF]]: ...
+def GetSaleDocumentPDF(api: object, documentId: int) -> ResponseEnvelope[PDF] | Awaitable[ResponseEnvelope[PDF]]:
+    params, data = _prepare_GetSaleDocumentPDF(documentId=documentId)
+    return invoke_operation(api, OP_GetSaleDocumentPDF, params=params, data=data)
+
+@overload
+def GetWarehouseDocumentPDF(api: SyncInvokerProtocol, documentId: int) -> ResponseEnvelope[PDF]: ...
+@overload
+def GetWarehouseDocumentPDF(api: SyncRequestProtocol, documentId: int) -> ResponseEnvelope[PDF]: ...
+@overload
+def GetWarehouseDocumentPDF(api: AsyncInvokerProtocol, documentId: int) -> Awaitable[ResponseEnvelope[PDF]]: ...
+@overload
+def GetWarehouseDocumentPDF(api: AsyncRequestProtocol, documentId: int) -> Awaitable[ResponseEnvelope[PDF]]: ...
+def GetWarehouseDocumentPDF(api: object, documentId: int) -> ResponseEnvelope[PDF] | Awaitable[ResponseEnvelope[PDF]]:
+    params, data = _prepare_GetWarehouseDocumentPDF(documentId=documentId)
+    return invoke_operation(api, OP_GetWarehouseDocumentPDF, params=params, data=data)
+
+__all__ = ["GetOrderPDF", "GetSaleDocumentPDF", "GetWarehouseDocumentPDF"]

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssReportsController/_common.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_GetOrderPDF = ('GET', '/api/OssReports/Order')
+def _prepare_GetOrderPDF(*, orderId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["orderId"] = orderId
+    data = None
+    return params or None, data
+
+_REQUEST_GetSaleDocumentPDF = ('GET', '/api/OssReports/SaleDocument')
+def _prepare_GetSaleDocumentPDF(*, documentId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentId"] = documentId
+    data = None
+    return params or None, data
+
+_REQUEST_GetWarehouseDocumentPDF = ('GET', '/api/OssReports/WarehouseDocument')
+def _prepare_GetWarehouseDocumentPDF(*, documentId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentId"] = documentId
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssReportsController/_ops.py

@@ -0,0 +1,24 @@
+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.Common.ViewModels import PDF
+
+_ADAPTER_GetOrderPDF = TypeAdapter(PDF)
+
+def _parse_GetOrderPDF(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[PDF]:
+    return parse_with_adapter(envelope, _ADAPTER_GetOrderPDF)
+OP_GetOrderPDF = OperationSpec(method='GET', path='/api/OssReports/Order', parser=_parse_GetOrderPDF)
+
+_ADAPTER_GetSaleDocumentPDF = TypeAdapter(PDF)
+
+def _parse_GetSaleDocumentPDF(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[PDF]:
+    return parse_with_adapter(envelope, _ADAPTER_GetSaleDocumentPDF)
+OP_GetSaleDocumentPDF = OperationSpec(method='GET', path='/api/OssReports/SaleDocument', parser=_parse_GetSaleDocumentPDF)
+
+_ADAPTER_GetWarehouseDocumentPDF = TypeAdapter(PDF)
+
+def _parse_GetWarehouseDocumentPDF(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[PDF]:
+    return parse_with_adapter(envelope, _ADAPTER_GetWarehouseDocumentPDF)
+OP_GetWarehouseDocumentPDF = OperationSpec(method='GET', path='/api/OssReports/WarehouseDocument', parser=_parse_GetWarehouseDocumentPDF)

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssSaleController/__init__.py

@@ -0,0 +1,58 @@
+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.OSS.ViewModels.Sales import OssDomesticSaleDocument
+from SymfWebAPI.WebAPI.Interface.OSS.ViewModels.Sales.V2026_1 import OssSaleDocument
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleDocument
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleDocumentWZ
+from ._common import (
+    _prepare_AddNew,
+    _prepare_AddNewReceipt,
+    _prepare_IssueWZ,
+)
+from ._ops import (
+    OP_AddNew,
+    OP_AddNewReceipt,
+    OP_IssueWZ,
+)
+
+@overload
+def AddNew(api: SyncInvokerProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", saleDocument: "OssSaleDocument") -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def AddNew(api: SyncRequestProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", saleDocument: "OssSaleDocument") -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def AddNew(api: AsyncInvokerProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", saleDocument: "OssSaleDocument") -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+@overload
+def AddNew(api: AsyncRequestProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", saleDocument: "OssSaleDocument") -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+def AddNew(api: object, issue: bool, invoiceKind: "IssueInvoiceKind", saleDocument: "OssSaleDocument") -> ResponseEnvelope[SaleDocument] | Awaitable[ResponseEnvelope[SaleDocument]]:
+    params, data = _prepare_AddNew(issue=issue, invoiceKind=invoiceKind, saleDocument=saleDocument)
+    return invoke_operation(api, OP_AddNew, params=params, data=data)
+
+@overload
+def AddNewReceipt(api: SyncInvokerProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", receipt: "OssDomesticSaleDocument") -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def AddNewReceipt(api: SyncRequestProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", receipt: "OssDomesticSaleDocument") -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def AddNewReceipt(api: AsyncInvokerProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", receipt: "OssDomesticSaleDocument") -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+@overload
+def AddNewReceipt(api: AsyncRequestProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", receipt: "OssDomesticSaleDocument") -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+def AddNewReceipt(api: object, issue: bool, invoiceKind: "IssueInvoiceKind", receipt: "OssDomesticSaleDocument") -> ResponseEnvelope[SaleDocument] | Awaitable[ResponseEnvelope[SaleDocument]]:
+    params, data = _prepare_AddNewReceipt(issue=issue, invoiceKind=invoiceKind, receipt=receipt)
+    return invoke_operation(api, OP_AddNewReceipt, params=params, data=data)
+
+@overload
+def IssueWZ(api: SyncInvokerProtocol, documentId: int, inBuffer: bool) -> ResponseEnvelope[List[SaleDocumentWZ]]: ...
+@overload
+def IssueWZ(api: SyncRequestProtocol, documentId: int, inBuffer: bool) -> ResponseEnvelope[List[SaleDocumentWZ]]: ...
+@overload
+def IssueWZ(api: AsyncInvokerProtocol, documentId: int, inBuffer: bool) -> Awaitable[ResponseEnvelope[List[SaleDocumentWZ]]]: ...
+@overload
+def IssueWZ(api: AsyncRequestProtocol, documentId: int, inBuffer: bool) -> Awaitable[ResponseEnvelope[List[SaleDocumentWZ]]]: ...
+def IssueWZ(api: object, documentId: int, inBuffer: bool) -> ResponseEnvelope[List[SaleDocumentWZ]] | Awaitable[ResponseEnvelope[List[SaleDocumentWZ]]]:
+    params, data = _prepare_IssueWZ(documentId=documentId, inBuffer=inBuffer)
+    return invoke_operation(api, OP_IssueWZ, params=params, data=data)
+
+__all__ = ["AddNew", "AddNewReceipt", "IssueWZ"]

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssSaleController/_common.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_AddNew = ('POST', '/api/OssSale/New')
+def _prepare_AddNew(*, issue, invoiceKind, saleDocument) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["issue"] = issue
+    params["invoiceKind"] = invoiceKind
+    data = saleDocument.model_dump_json(exclude_unset=True) if saleDocument is not None else None
+    return params or None, data
+
+_REQUEST_AddNewReceipt = ('POST', '/api/OssSale/NewReceipt')
+def _prepare_AddNewReceipt(*, issue, invoiceKind, receipt) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["issue"] = issue
+    params["invoiceKind"] = invoiceKind
+    data = receipt.model_dump_json(exclude_unset=True) if receipt is not None else None
+    return params or None, data
+
+_REQUEST_IssueWZ = ('PUT', '/api/OssSale/WZ')
+def _prepare_IssueWZ(*, documentId, inBuffer) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentId"] = documentId
+    params["inBuffer"] = inBuffer
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/OSS/Interfaces/IOssSaleController/_ops.py

@@ -0,0 +1,28 @@
+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.OSS.ViewModels.Sales import OssDomesticSaleDocument
+from SymfWebAPI.WebAPI.Interface.OSS.ViewModels.Sales.V2026_1 import OssSaleDocument
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleDocument
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleDocumentWZ
+
+_ADAPTER_AddNew = TypeAdapter(SaleDocument)
+
+def _parse_AddNew(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[SaleDocument]:
+    return parse_with_adapter(envelope, _ADAPTER_AddNew)
+OP_AddNew = OperationSpec(method='POST', path='/api/OssSale/New', parser=_parse_AddNew)
+
+_ADAPTER_AddNewReceipt = TypeAdapter(SaleDocument)
+
+def _parse_AddNewReceipt(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[SaleDocument]:
+    return parse_with_adapter(envelope, _ADAPTER_AddNewReceipt)
+OP_AddNewReceipt = OperationSpec(method='POST', path='/api/OssSale/NewReceipt', parser=_parse_AddNewReceipt)
+
+_ADAPTER_IssueWZ = TypeAdapter(List[SaleDocumentWZ])
+
+def _parse_IssueWZ(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[SaleDocumentWZ]]:
+    return parse_with_adapter(envelope, _ADAPTER_IssueWZ)
+OP_IssueWZ = OperationSpec(method='PUT', path='/api/OssSale/WZ', parser=_parse_IssueWZ)

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

@@ -0,0 +1,26 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("IOssContractorsController", "IOssOrderController", "IOssProductController", "IOssProductMapsController", "IOssReportsController", "IOssSaleController",)
+
+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 IOssContractorsController as _IOssContractorsController
+    from . import IOssOrderController as _IOssOrderController
+    from . import IOssProductController as _IOssProductController
+    from . import IOssProductMapsController as _IOssProductMapsController
+    from . import IOssReportsController as _IOssReportsController
+    from . import IOssSaleController as _IOssSaleController

SymfWebAPI/WebAPI/Interface/OSS/ViewModels/Common/__init__.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from typing import Optional
+from decimal import Decimal
+
+class OssCatalog(BaseModel):
+    FullPath: str
+    AddIfNotExist: bool
+
+class OssContractor(BaseModel):
+    Id: Optional[int]
+    Code: str
+    RecalculatePrices: bool
+    Data: "OssOrderContractorData"
+
+class OssDelivery(BaseModel):
+    Id: Optional[int]
+    Code: str
+    Quantity: Decimal
+
+class OssKind(BaseModel):
+    Code: str
+    AddIfNotExist: bool
+
+class OssOrderContractorData(BaseModel):
+    Name: str
+    NIP: str
+    City: str
+    Street: str
+    HouseNo: str
+    ApartmentNo: str
+    PostCode: str
+    Country: str

SymfWebAPI/WebAPI/Interface/OSS/ViewModels/Orders/__init__.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from typing import List, Optional
+from datetime import datetime
+from decimal import Decimal
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels import PaymentRegistryBase
+from SymfWebAPI.WebAPI.Interface.Enums import (
+    enumDocumentReservationType,
+    enumPriceKind,
+    enumSalePriceType,
+)
+from SymfWebAPI.WebAPI.Interface.OSS.ViewModels.Common import (
+    OssCatalog,
+    OssContractor,
+    OssDelivery,
+    OssKind,
+)
+
+class OssOrder(BaseModel):
+    IssueDate: Optional[datetime]
+    SaleDate: Optional[datetime]
+    MaturityDate: Optional[datetime]
+    PaymentRegistry: "PaymentRegistryBase"
+    PaymentFormId: int
+    Currency: str
+    CurrencyRate: Decimal
+    SalePriceType: "enumSalePriceType"
+    PriceKind: "enumPriceKind"
+    ReservationType: "enumDocumentReservationType"
+    Buyer: "OssContractor"
+    Recipient: "OssContractor"
+    Catalog: "OssCatalog"
+    Kind: "OssKind"
+    Marker: int
+    ReceivedBy: str
+    Description: str
+    Note: str
+    Country: str
+    ShopOrderId: str
+    TypeExternal: int
+    IdExternal: Optional[int]
+    Id2External: Optional[str]
+    Positions: List["OssOrderPosition"]
+
+class OssOrderPosition(BaseModel):
+    Elements: List["OssOrderPositionElement"]
+    ErpProductId: Optional[int]
+    ShopProductId: str
+    Quantity: Decimal
+    UnitOfMeasurement: str
+    Value: Decimal
+    Description: str
+    Deliveries: List["OssDelivery"]
+
+class OssOrderPositionElement(BaseModel):
+    ErpProductId: Optional[int]
+    ShopProductId: str
+    Quantity: Decimal
+    UnitOfMeasurement: str
+    Value: Decimal
+    Description: str
+    Deliveries: List["OssDelivery"]

SymfWebAPI/WebAPI/Interface/OSS/ViewModels/Sales/V2026_1/__init__.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from typing import List, Optional
+from datetime import datetime
+from decimal import Decimal
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels import PaymentRegistryBase
+from SymfWebAPI.WebAPI.Interface.Enums import (
+    enumDocumentReservationType,
+    enumPriceKind,
+    enumSalePriceType,
+)
+from SymfWebAPI.WebAPI.Interface.OSS.ViewModels.Common import OssCatalog, OssContractor, OssKind
+from SymfWebAPI.WebAPI.Interface.OSS.ViewModels.Sales import OssSaleDocumentPosition
+
+class OssSaleDocument(BaseModel):
+    ThirdPartyContractor: "OssContractor"
+    Currency: str
+    CurrencyRate: Decimal
+    Country: str
+    IssueDate: Optional[datetime]
+    SaleDate: Optional[datetime]
+    MaturityDate: Optional[datetime]
+    PaymentRegistry: "PaymentRegistryBase"
+    PaymentFormId: int
+    SalePriceType: "enumSalePriceType"
+    PriceKind: "enumPriceKind"
+    ReservationType: "enumDocumentReservationType"
+    Buyer: "OssContractor"
+    Recipient: "OssContractor"
+    Catalog: "OssCatalog"
+    Kind: "OssKind"
+    Marker: int
+    ReceivedBy: str
+    Description: str
+    Note: str
+    ShopOrderId: str
+    ShippingCountry: str
+    TypeExternal: int
+    IdExternal: Optional[int]
+    Id2External: Optional[str]
+    Positions: List["OssSaleDocumentPosition"]

SymfWebAPI/WebAPI/Interface/OSS/ViewModels/Sales/__init__.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+import importlib
+from typing import TYPE_CHECKING
+from typing import List, Optional
+from datetime import datetime
+from decimal import Decimal
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels import PaymentRegistryBase
+from SymfWebAPI.WebAPI.Interface.Enums import (
+    enumDocumentReservationType,
+    enumPriceKind,
+    enumSalePriceType,
+)
+from SymfWebAPI.WebAPI.Interface.OSS.ViewModels.Common import (
+    OssCatalog,
+    OssContractor,
+    OssDelivery,
+    OssKind,
+)
+
+class OssDomesticSaleDocument(BaseModel):
+    IssueDate: Optional[datetime]
+    SaleDate: Optional[datetime]
+    MaturityDate: Optional[datetime]
+    PaymentRegistry: "PaymentRegistryBase"
+    PaymentFormId: int
+    SalePriceType: "enumSalePriceType"
+    PriceKind: "enumPriceKind"
+    ReservationType: "enumDocumentReservationType"
+    Buyer: "OssContractor"
+    Recipient: "OssContractor"
+    Catalog: "OssCatalog"
+    Kind: "OssKind"
+    Marker: int
+    ReceivedBy: str
+    Description: str
+    Note: str
+    ShopOrderId: str
+    ShippingCountry: str
+    TypeExternal: int
+    IdExternal: Optional[int]
+    Id2External: str
+    Positions: List["OssSaleDocumentPosition"]
+
+class OssSaleDocumentPosition(BaseModel):
+    Elements: List["OssSaleDocumentPositionElement"]
+    ErpProductId: Optional[int]
+    ShopProductId: str
+    Quantity: Decimal
+    UnitOfMeasurement: str
+    Value: Decimal
+    Description: str
+    Deliveries: List["OssDelivery"]
+    OssService: Optional[bool]
+
+class OssSaleDocumentPositionElement(BaseModel):
+    ErpProductId: Optional[int]
+    ShopProductId: str
+    Quantity: Decimal
+    UnitOfMeasurement: str
+    Value: Decimal
+    Description: str
+    Deliveries: List["OssDelivery"]
+    OssService: Optional[bool]
+
+_VERSIONED_EXPORTS = {
+    'OssSaleDocument': 'V2026_1',
+}
+
+def __getattr__(name: str):
+    child_name = _VERSIONED_EXPORTS.get(name)
+    if child_name is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    module = importlib.import_module(f".{child_name}", __name__)
+    value = getattr(module, name)
+    globals()[name] = value
+    return value
+
+def __dir__():
+    return sorted(set(_VERSIONED_EXPORTS) | {n for n in globals() if not n.startswith('_')})
+
+if TYPE_CHECKING:
+    from .V2026_1 import OssSaleDocument