SymfWebAPI 1.26.10.1__py3-none-any.whl

SymfWebAPI/WebAPI/Interface/FKF/Documents/__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/FKF/Employees/Interfaces/IFKEmployeesController/__init__.py

@@ -0,0 +1,99 @@
+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.Employees.ViewModels import Employee
+from SymfWebAPI.WebAPI.Interface.ViewModels import Page
+from SymfWebAPI.WebAPI.Interface.Enums import enumOrderByType
+from ._common import (
+    _prepare_GetById,
+    _prepare_GetByPosition,
+    _prepare_GetByCode,
+    _prepare_AddNew,
+    _prepare_Update,
+    _prepare_GetPagedDocument,
+)
+from ._ops import (
+    OP_GetById,
+    OP_GetByPosition,
+    OP_GetByCode,
+    OP_AddNew,
+    OP_Update,
+    OP_GetPagedDocument,
+)
+
+@overload
+def GetById(api: SyncInvokerProtocol, id: int) -> ResponseEnvelope[Employee]: ...
+@overload
+def GetById(api: SyncRequestProtocol, id: int) -> ResponseEnvelope[Employee]: ...
+@overload
+def GetById(api: AsyncInvokerProtocol, id: int) -> Awaitable[ResponseEnvelope[Employee]]: ...
+@overload
+def GetById(api: AsyncRequestProtocol, id: int) -> Awaitable[ResponseEnvelope[Employee]]: ...
+def GetById(api: object, id: int) -> ResponseEnvelope[Employee] | Awaitable[ResponseEnvelope[Employee]]:
+    params, data = _prepare_GetById(id=id)
+    return invoke_operation(api, OP_GetById, params=params, data=data)
+
+@overload
+def GetByPosition(api: SyncInvokerProtocol, position: int) -> ResponseEnvelope[Employee]: ...
+@overload
+def GetByPosition(api: SyncRequestProtocol, position: int) -> ResponseEnvelope[Employee]: ...
+@overload
+def GetByPosition(api: AsyncInvokerProtocol, position: int) -> Awaitable[ResponseEnvelope[Employee]]: ...
+@overload
+def GetByPosition(api: AsyncRequestProtocol, position: int) -> Awaitable[ResponseEnvelope[Employee]]: ...
+def GetByPosition(api: object, position: int) -> ResponseEnvelope[Employee] | Awaitable[ResponseEnvelope[Employee]]:
+    params, data = _prepare_GetByPosition(position=position)
+    return invoke_operation(api, OP_GetByPosition, params=params, data=data)
+
+@overload
+def GetByCode(api: SyncInvokerProtocol, code: str) -> ResponseEnvelope[Employee]: ...
+@overload
+def GetByCode(api: SyncRequestProtocol, code: str) -> ResponseEnvelope[Employee]: ...
+@overload
+def GetByCode(api: AsyncInvokerProtocol, code: str) -> Awaitable[ResponseEnvelope[Employee]]: ...
+@overload
+def GetByCode(api: AsyncRequestProtocol, code: str) -> Awaitable[ResponseEnvelope[Employee]]: ...
+def GetByCode(api: object, code: str) -> ResponseEnvelope[Employee] | Awaitable[ResponseEnvelope[Employee]]:
+    params, data = _prepare_GetByCode(code=code)
+    return invoke_operation(api, OP_GetByCode, params=params, data=data)
+
+@overload
+def AddNew(api: SyncInvokerProtocol, employee: "Employee") -> ResponseEnvelope[Employee]: ...
+@overload
+def AddNew(api: SyncRequestProtocol, employee: "Employee") -> ResponseEnvelope[Employee]: ...
+@overload
+def AddNew(api: AsyncInvokerProtocol, employee: "Employee") -> Awaitable[ResponseEnvelope[Employee]]: ...
+@overload
+def AddNew(api: AsyncRequestProtocol, employee: "Employee") -> Awaitable[ResponseEnvelope[Employee]]: ...
+def AddNew(api: object, employee: "Employee") -> ResponseEnvelope[Employee] | Awaitable[ResponseEnvelope[Employee]]:
+    params, data = _prepare_AddNew(employee=employee)
+    return invoke_operation(api, OP_AddNew, params=params, data=data)
+
+@overload
+def Update(api: SyncInvokerProtocol, employee: "Employee") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, employee: "Employee") -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: AsyncInvokerProtocol, employee: "Employee") -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def Update(api: AsyncRequestProtocol, employee: "Employee") -> Awaitable[ResponseEnvelope[None]]: ...
+def Update(api: object, employee: "Employee") -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_Update(employee=employee)
+    return invoke_operation(api, OP_Update, 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)
+
+__all__ = ["GetById", "GetByPosition", "GetByCode", "AddNew", "Update", "GetPagedDocument"]

SymfWebAPI/WebAPI/Interface/FKF/Employees/Interfaces/IFKEmployeesController/_common.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_GetById = ('GET', '/api/FKEmployees')
+def _prepare_GetById(*, id) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    data = None
+    return params or None, data
+
+_REQUEST_GetByPosition = ('GET', '/api/FKEmployees')
+def _prepare_GetByPosition(*, position) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["position"] = position
+    data = None
+    return params or None, data
+
+_REQUEST_GetByCode = ('GET', '/api/FKEmployees')
+def _prepare_GetByCode(*, code) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["code"] = code
+    data = None
+    return params or None, data
+
+_REQUEST_AddNew = ('POST', '/api/FKEmployees/Create')
+def _prepare_AddNew(*, employee) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = employee.model_dump_json(exclude_unset=True) if employee is not None else None
+    return params or None, data
+
+_REQUEST_Update = ('PUT', '/api/FKEmployees/Update')
+def _prepare_Update(*, employee) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = employee.model_dump_json(exclude_unset=True) if employee is not None else None
+    return params or None, data
+
+_REQUEST_GetPagedDocument = ('GET', '/api/FKEmployees/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

SymfWebAPI/WebAPI/Interface/FKF/Employees/Interfaces/IFKEmployeesController/_ops.py

@@ -0,0 +1,42 @@
+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.Employees.ViewModels import Employee
+from SymfWebAPI.WebAPI.Interface.ViewModels import Page
+from SymfWebAPI.WebAPI.Interface.Enums import enumOrderByType
+
+_ADAPTER_GetById = TypeAdapter(Employee)
+
+def _parse_GetById(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Employee]:
+    return parse_with_adapter(envelope, _ADAPTER_GetById)
+OP_GetById = OperationSpec(method='GET', path='/api/FKEmployees', parser=_parse_GetById)
+
+_ADAPTER_GetByPosition = TypeAdapter(Employee)
+
+def _parse_GetByPosition(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Employee]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByPosition)
+OP_GetByPosition = OperationSpec(method='GET', path='/api/FKEmployees', parser=_parse_GetByPosition)
+
+_ADAPTER_GetByCode = TypeAdapter(Employee)
+
+def _parse_GetByCode(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Employee]:
+    return parse_with_adapter(envelope, _ADAPTER_GetByCode)
+OP_GetByCode = OperationSpec(method='GET', path='/api/FKEmployees', parser=_parse_GetByCode)
+
+_ADAPTER_AddNew = TypeAdapter(Employee)
+
+def _parse_AddNew(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[Employee]:
+    return parse_with_adapter(envelope, _ADAPTER_AddNew)
+OP_AddNew = OperationSpec(method='POST', path='/api/FKEmployees/Create', parser=_parse_AddNew)
+
+def _parse_Update(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_Update = OperationSpec(method='PUT', path='/api/FKEmployees/Update', parser=_parse_Update)
+
+_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/FKEmployees/Page', parser=_parse_GetPagedDocument)

SymfWebAPI/WebAPI/Interface/FKF/Employees/Interfaces/__init__.py

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

SymfWebAPI/WebAPI/Interface/FKF/Employees/ViewModels/__init__.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from typing import Optional
+
+class Employee(BaseModel):
+    Id: Optional[int]
+    Position: Optional[int]
+    Active: bool
+    Code: str
+    Name: str
+    SecondName: str
+    Surname: str
+    NIP: str
+    Pesel: str
+    Phone: str
+    Address: "EmployeeAddress"
+    BankInfo: "EmployeeBankInfo"
+
+class EmployeeAddress(BaseModel):
+    City: str
+    Street: str
+    HouseNo: str
+    ApartmentNo: str
+    PostCode: str
+
+class EmployeeBankInfo(BaseModel):
+    AccountNumber: str
+    BankName: str

SymfWebAPI/WebAPI/Interface/FKF/Employees/__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/FKF/__init__.py

@@ -0,0 +1,27 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("AccountsChart", "Calculations", "Common", "Contractors", "Dimensions", "Documents", "Employees",)
+
+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 AccountsChart as _AccountsChart
+    from . import Calculations as _Calculations
+    from . import Common as _Common
+    from . import Contractors as _Contractors
+    from . import Dimensions as _Dimensions
+    from . import Documents as _Documents
+    from . import Employees as _Employees

SymfWebAPI/WebAPI/Interface/HMF/Develogic/Interfaces/IDevelogicPurchasesController/__init__.py

@@ -0,0 +1,28 @@
+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.Purchases.ViewModels.V2026_1 import PurchaseDocument
+from SymfWebAPI.WebAPI.Interface.Purchases.ViewModels.V2026_1 import PurchaseDocumentIssue
+from ._common import (
+    _prepare_AddNew,
+)
+from ._ops import (
+    OP_AddNew,
+)
+
+@overload
+def AddNew(api: SyncInvokerProtocol, issue: bool, document: "PurchaseDocumentIssue") -> ResponseEnvelope[PurchaseDocument]: ...
+@overload
+def AddNew(api: SyncRequestProtocol, issue: bool, document: "PurchaseDocumentIssue") -> ResponseEnvelope[PurchaseDocument]: ...
+@overload
+def AddNew(api: AsyncInvokerProtocol, issue: bool, document: "PurchaseDocumentIssue") -> Awaitable[ResponseEnvelope[PurchaseDocument]]: ...
+@overload
+def AddNew(api: AsyncRequestProtocol, issue: bool, document: "PurchaseDocumentIssue") -> Awaitable[ResponseEnvelope[PurchaseDocument]]: ...
+def AddNew(api: object, issue: bool, document: "PurchaseDocumentIssue") -> ResponseEnvelope[PurchaseDocument] | Awaitable[ResponseEnvelope[PurchaseDocument]]:
+    params, data = _prepare_AddNew(issue=issue, document=document)
+    return invoke_operation(api, OP_AddNew, params=params, data=data)
+
+__all__ = ["AddNew"]

SymfWebAPI/WebAPI/Interface/HMF/Develogic/Interfaces/IDevelogicPurchasesController/_common.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_AddNew = ('POST', '/api/DevelogicPurchases/Invoice')
+def _prepare_AddNew(*, issue, document) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["issue"] = issue
+    data = document.model_dump_json(exclude_unset=True) if document is not None else None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/HMF/Develogic/Interfaces/IDevelogicPurchasesController/_ops.py

@@ -0,0 +1,13 @@
+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.Purchases.ViewModels.V2026_1 import PurchaseDocument
+from SymfWebAPI.WebAPI.Interface.Purchases.ViewModels.V2026_1 import PurchaseDocumentIssue
+
+_ADAPTER_AddNew = TypeAdapter(PurchaseDocument)
+
+def _parse_AddNew(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[PurchaseDocument]:
+    return parse_with_adapter(envelope, _ADAPTER_AddNew)
+OP_AddNew = OperationSpec(method='POST', path='/api/DevelogicPurchases/Invoice', parser=_parse_AddNew)

SymfWebAPI/WebAPI/Interface/HMF/Develogic/Interfaces/IDevelogicSalesController/__init__.py

@@ -0,0 +1,58 @@
+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.HMF.Develogic.ViewModels import DevelogicAdvancePayment
+from SymfWebAPI.WebAPI.Interface.HMF.Develogic.ViewModels import DevelogicContractInvoiceIssue
+from SymfWebAPI.WebAPI.Interface.HMF.Develogic.ViewModels.V2026_1 import DevelogicDocumentIssue
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleDocument
+from ._common import (
+    _prepare_AddNew,
+    _prepare_IssueAdvancePayment,
+    _prepare_IssueContractInvoice,
+)
+from ._ops import (
+    OP_AddNew,
+    OP_IssueAdvancePayment,
+    OP_IssueContractInvoice,
+)
+
+@overload
+def AddNew(api: SyncInvokerProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", document: "DevelogicDocumentIssue") -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def AddNew(api: SyncRequestProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", document: "DevelogicDocumentIssue") -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def AddNew(api: AsyncInvokerProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", document: "DevelogicDocumentIssue") -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+@overload
+def AddNew(api: AsyncRequestProtocol, issue: bool, invoiceKind: "IssueInvoiceKind", document: "DevelogicDocumentIssue") -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+def AddNew(api: object, issue: bool, invoiceKind: "IssueInvoiceKind", document: "DevelogicDocumentIssue") -> ResponseEnvelope[SaleDocument] | Awaitable[ResponseEnvelope[SaleDocument]]:
+    params, data = _prepare_AddNew(issue=issue, invoiceKind=invoiceKind, document=document)
+    return invoke_operation(api, OP_AddNew, params=params, data=data)
+
+@overload
+def IssueAdvancePayment(api: SyncInvokerProtocol, contractId: "DevelogicAdvancePayment", invoiceKind: int) -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def IssueAdvancePayment(api: SyncRequestProtocol, contractId: "DevelogicAdvancePayment", invoiceKind: int) -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def IssueAdvancePayment(api: AsyncInvokerProtocol, contractId: "DevelogicAdvancePayment", invoiceKind: int) -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+@overload
+def IssueAdvancePayment(api: AsyncRequestProtocol, contractId: "DevelogicAdvancePayment", invoiceKind: int) -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+def IssueAdvancePayment(api: object, contractId: "DevelogicAdvancePayment", invoiceKind: int) -> ResponseEnvelope[SaleDocument] | Awaitable[ResponseEnvelope[SaleDocument]]:
+    params, data = _prepare_IssueAdvancePayment(contractId=contractId, invoiceKind=invoiceKind)
+    return invoke_operation(api, OP_IssueAdvancePayment, params=params, data=data)
+
+@overload
+def IssueContractInvoice(api: SyncInvokerProtocol, contractId: "DevelogicContractInvoiceIssue", invoiceKind: int) -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def IssueContractInvoice(api: SyncRequestProtocol, contractId: "DevelogicContractInvoiceIssue", invoiceKind: int) -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def IssueContractInvoice(api: AsyncInvokerProtocol, contractId: "DevelogicContractInvoiceIssue", invoiceKind: int) -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+@overload
+def IssueContractInvoice(api: AsyncRequestProtocol, contractId: "DevelogicContractInvoiceIssue", invoiceKind: int) -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+def IssueContractInvoice(api: object, contractId: "DevelogicContractInvoiceIssue", invoiceKind: int) -> ResponseEnvelope[SaleDocument] | Awaitable[ResponseEnvelope[SaleDocument]]:
+    params, data = _prepare_IssueContractInvoice(contractId=contractId, invoiceKind=invoiceKind)
+    return invoke_operation(api, OP_IssueContractInvoice, params=params, data=data)
+
+__all__ = ["AddNew", "IssueAdvancePayment", "IssueContractInvoice"]

SymfWebAPI/WebAPI/Interface/HMF/Develogic/Interfaces/IDevelogicSalesController/_common.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_AddNew = ('POST', '/api/DevelogicSales/Invoice')
+def _prepare_AddNew(*, issue, invoiceKind, document) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["issue"] = issue
+    params["invoiceKind"] = invoiceKind
+    data = document.model_dump_json(exclude_unset=True) if document is not None else None
+    return params or None, data
+
+_REQUEST_IssueAdvancePayment = ('POST', '/api/DevelogicSales/AdvancePayment')
+def _prepare_IssueAdvancePayment(*, contractId, invoiceKind) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["contractId"] = contractId
+    params["invoiceKind"] = invoiceKind
+    data = None
+    return params or None, data
+
+_REQUEST_IssueContractInvoice = ('POST', '/api/DevelogicSales/ContractInvoice')
+def _prepare_IssueContractInvoice(*, contractId, invoiceKind) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["contractId"] = contractId
+    params["invoiceKind"] = invoiceKind
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/HMF/Develogic/Interfaces/IDevelogicSalesController/_ops.py

@@ -0,0 +1,27 @@
+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.HMF.Develogic.ViewModels import DevelogicAdvancePayment
+from SymfWebAPI.WebAPI.Interface.HMF.Develogic.ViewModels import DevelogicContractInvoiceIssue
+from SymfWebAPI.WebAPI.Interface.HMF.Develogic.ViewModels.V2026_1 import DevelogicDocumentIssue
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleDocument
+
+_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/DevelogicSales/Invoice', parser=_parse_AddNew)
+
+_ADAPTER_IssueAdvancePayment = TypeAdapter(SaleDocument)
+
+def _parse_IssueAdvancePayment(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[SaleDocument]:
+    return parse_with_adapter(envelope, _ADAPTER_IssueAdvancePayment)
+OP_IssueAdvancePayment = OperationSpec(method='POST', path='/api/DevelogicSales/AdvancePayment', parser=_parse_IssueAdvancePayment)
+
+_ADAPTER_IssueContractInvoice = TypeAdapter(SaleDocument)
+
+def _parse_IssueContractInvoice(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[SaleDocument]:
+    return parse_with_adapter(envelope, _ADAPTER_IssueContractInvoice)
+OP_IssueContractInvoice = OperationSpec(method='POST', path='/api/DevelogicSales/ContractInvoice', parser=_parse_IssueContractInvoice)

SymfWebAPI/WebAPI/Interface/HMF/Develogic/Interfaces/__init__.py

@@ -0,0 +1,22 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("IDevelogicPurchasesController", "IDevelogicSalesController",)
+
+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 IDevelogicPurchasesController as _IDevelogicPurchasesController
+    from . import IDevelogicSalesController as _IDevelogicSalesController

SymfWebAPI/WebAPI/Interface/HMF/Develogic/ViewModels/V2026_1/__init__.py

@@ -0,0 +1,62 @@
+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,
+    enumJPK_V7DocumentAttribute,
+    enumPriceKind,
+    enumSalePriceType,
+)
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import (
+    SaleDocumentIssueCatalog,
+    SaleDocumentIssueContractor,
+    SaleDocumentIssueKind,
+    SaleDocumentIssuePosition,
+)
+
+class DevelogicDocumentIssue(BaseModel):
+    ThirdPartyContractor: "SaleDocumentIssueContractor"
+    SubAccountNumber: str
+    TypeCode: str
+    Series: str
+    NumberInSeries: Optional[int]
+    Department: str
+    Warehouse: str
+    ReservationType: Optional["enumDocumentReservationType"]
+    PaymentRegistry: "PaymentRegistryBase"
+    PaymentFormId: int
+    IssueDate: Optional[datetime]
+    SaleDate: Optional[datetime]
+    MaturityDate: Optional[datetime]
+    Currency: str
+    CurrencyRate: Decimal
+    CurrencyRateCIT: Decimal
+    SalePriceType: "enumSalePriceType"
+    PriceKind: "enumPriceKind"
+    SplitPayment: bool
+    JPK_V7Attributes: Optional["enumJPK_V7DocumentAttribute"]
+    eArchiveId: Optional[str]
+    NumberKSeF: str
+    IssueDateKSeF: Optional[datetime]
+    Buyer: "SaleDocumentIssueContractor"
+    Recipient: "SaleDocumentIssueContractor"
+    Positions: List["SaleDocumentIssuePosition"]
+    Catalog: "SaleDocumentIssueCatalog"
+    Kind: "SaleDocumentIssueKind"
+    Marker: int
+    ReceivedBy: str
+    Description: str
+    Note: str
+    OssProcedure: Optional[bool]
+    OssShippingCountry: str
+    OssDeliveryCountry: str
+    TypeExternal: Optional[int]
+    IdExternal: Optional[int]
+    Id2External: str
+    DocumentExternalMetadata: str
+    IsSmeProcedure: bool

SymfWebAPI/WebAPI/Interface/HMF/Develogic/ViewModels/__init__.py

@@ -0,0 +1,69 @@
+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,
+    enumJPK_V7DocumentAttribute,
+    enumSalePriceType,
+)
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import (
+    SaleDocumentIssueCatalog,
+    SaleDocumentIssueKind,
+)
+
+class DevelogicAdvancePayment(BaseModel):
+    Value: Decimal
+    IsFinal: bool
+
+class DevelogicContractInvoiceIssue(BaseModel):
+    TypeCode: str
+    Series: str
+    CorrectionTypeCode: str
+    CorrectionSeries: str
+    NumberInSeries: Optional[int]
+    ReservationType: Optional["enumDocumentReservationType"]
+    PaymentRegistry: "PaymentRegistryBase"
+    PaymentFormId: int
+    IssueDate: Optional[datetime]
+    SaleDate: Optional[datetime]
+    MaturityDate: Optional[datetime]
+    SalePriceType: "enumSalePriceType"
+    SplitPayment: bool
+    JPK_V7Attributes: Optional["enumJPK_V7DocumentAttribute"]
+    Catalog: "SaleDocumentIssueCatalog"
+    Kind: "SaleDocumentIssueKind"
+    Marker: int
+    ReceivedBy: str
+    Note: str
+    Positions: List["DevelogicContractInvoiceIssuePosition"]
+
+class DevelogicContractInvoiceIssuePosition(BaseModel):
+    ContractPositionId: int
+    Quantity: int
+    Value: Decimal
+
+_VERSIONED_EXPORTS = {
+    'DevelogicDocumentIssue': '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 DevelogicDocumentIssue

SymfWebAPI/WebAPI/Interface/HMF/Develogic/__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