SymfWebAPI 1.26.10.1__py3-none-any.whl

SymfWebAPI/WebAPI/Interface/Sales/Interfaces/ISalesDimensionsController/__init__.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from typing import Awaitable, List, overload
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels.Aspects import AspectDocument
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels.Aspects import AspectPositionEdit
+from SymfWebAPI.WebAPI.Interface.FKF.Common.ViewModels import Dimension
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels import PositionDimension
+from ._common import (
+    _prepare_Get,
+    _prepare_GetPositionsByDocumentId,
+    _prepare_GetPositionsByDocumentNumber,
+    _prepare_GetPosition,
+    _prepare_Update,
+    _prepare_UpdatePosition,
+    _prepare_GetAspects,
+    _prepare_UpdateAspect,
+)
+from ._ops import (
+    OP_Get,
+    OP_GetPositionsByDocumentId,
+    OP_GetPositionsByDocumentNumber,
+    OP_GetPosition,
+    OP_Update,
+    OP_UpdatePosition,
+    OP_GetAspects,
+    OP_UpdateAspect,
+)
+
+@overload
+def Get(api: SyncInvokerProtocol, documentNumber: str, buffer: bool) -> ResponseEnvelope[List[Dimension]]: ...
+@overload
+def Get(api: SyncRequestProtocol, documentNumber: str, buffer: bool) -> ResponseEnvelope[List[Dimension]]: ...
+@overload
+def Get(api: AsyncInvokerProtocol, documentNumber: str, buffer: bool) -> Awaitable[ResponseEnvelope[List[Dimension]]]: ...
+@overload
+def Get(api: AsyncRequestProtocol, documentNumber: str, buffer: bool) -> Awaitable[ResponseEnvelope[List[Dimension]]]: ...
+def Get(api: object, documentNumber: str, buffer: bool) -> ResponseEnvelope[List[Dimension]] | Awaitable[ResponseEnvelope[List[Dimension]]]:
+    params, data = _prepare_Get(documentNumber=documentNumber, buffer=buffer)
+    return invoke_operation(api, OP_Get, params=params, data=data)
+
+@overload
+def GetPositionsByDocumentId(api: SyncInvokerProtocol, documentId: int) -> ResponseEnvelope[List[PositionDimension]]: ...
+@overload
+def GetPositionsByDocumentId(api: SyncRequestProtocol, documentId: int) -> ResponseEnvelope[List[PositionDimension]]: ...
+@overload
+def GetPositionsByDocumentId(api: AsyncInvokerProtocol, documentId: int) -> Awaitable[ResponseEnvelope[List[PositionDimension]]]: ...
+@overload
+def GetPositionsByDocumentId(api: AsyncRequestProtocol, documentId: int) -> Awaitable[ResponseEnvelope[List[PositionDimension]]]: ...
+def GetPositionsByDocumentId(api: object, documentId: int) -> ResponseEnvelope[List[PositionDimension]] | Awaitable[ResponseEnvelope[List[PositionDimension]]]:
+    params, data = _prepare_GetPositionsByDocumentId(documentId=documentId)
+    return invoke_operation(api, OP_GetPositionsByDocumentId, params=params, data=data)
+
+@overload
+def GetPositionsByDocumentNumber(api: SyncInvokerProtocol, documentNumber: str, buffer: bool) -> ResponseEnvelope[List[PositionDimension]]: ...
+@overload
+def GetPositionsByDocumentNumber(api: SyncRequestProtocol, documentNumber: str, buffer: bool) -> ResponseEnvelope[List[PositionDimension]]: ...
+@overload
+def GetPositionsByDocumentNumber(api: AsyncInvokerProtocol, documentNumber: str, buffer: bool) -> Awaitable[ResponseEnvelope[List[PositionDimension]]]: ...
+@overload
+def GetPositionsByDocumentNumber(api: AsyncRequestProtocol, documentNumber: str, buffer: bool) -> Awaitable[ResponseEnvelope[List[PositionDimension]]]: ...
+def GetPositionsByDocumentNumber(api: object, documentNumber: str, buffer: bool) -> ResponseEnvelope[List[PositionDimension]] | Awaitable[ResponseEnvelope[List[PositionDimension]]]:
+    params, data = _prepare_GetPositionsByDocumentNumber(documentNumber=documentNumber, buffer=buffer)
+    return invoke_operation(api, OP_GetPositionsByDocumentNumber, params=params, data=data)
+
+@overload
+def GetPosition(api: SyncInvokerProtocol, positionId: int) -> ResponseEnvelope[List[Dimension]]: ...
+@overload
+def GetPosition(api: SyncRequestProtocol, positionId: int) -> ResponseEnvelope[List[Dimension]]: ...
+@overload
+def GetPosition(api: AsyncInvokerProtocol, positionId: int) -> Awaitable[ResponseEnvelope[List[Dimension]]]: ...
+@overload
+def GetPosition(api: AsyncRequestProtocol, positionId: int) -> Awaitable[ResponseEnvelope[List[Dimension]]]: ...
+def GetPosition(api: object, positionId: int) -> ResponseEnvelope[List[Dimension]] | Awaitable[ResponseEnvelope[List[Dimension]]]:
+    params, data = _prepare_GetPosition(positionId=positionId)
+    return invoke_operation(api, OP_GetPosition, params=params, data=data)
+
+@overload
+def Update(api: SyncInvokerProtocol, documentNumber: str, buffer: List["Dimension"], documentDimensions: bool) -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, documentNumber: str, buffer: List["Dimension"], documentDimensions: bool) -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: AsyncInvokerProtocol, documentNumber: str, buffer: List["Dimension"], documentDimensions: bool) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def Update(api: AsyncRequestProtocol, documentNumber: str, buffer: List["Dimension"], documentDimensions: bool) -> Awaitable[ResponseEnvelope[None]]: ...
+def Update(api: object, documentNumber: str, buffer: List["Dimension"], documentDimensions: bool) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_Update(documentNumber=documentNumber, buffer=buffer, documentDimensions=documentDimensions)
+    return invoke_operation(api, OP_Update, params=params, data=data)
+
+@overload
+def UpdatePosition(api: SyncInvokerProtocol, positionDimension: List["PositionDimension"]) -> ResponseEnvelope[None]: ...
+@overload
+def UpdatePosition(api: SyncRequestProtocol, positionDimension: List["PositionDimension"]) -> ResponseEnvelope[None]: ...
+@overload
+def UpdatePosition(api: AsyncInvokerProtocol, positionDimension: List["PositionDimension"]) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def UpdatePosition(api: AsyncRequestProtocol, positionDimension: List["PositionDimension"]) -> Awaitable[ResponseEnvelope[None]]: ...
+def UpdatePosition(api: object, positionDimension: List["PositionDimension"]) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_UpdatePosition(positionDimension=positionDimension)
+    return invoke_operation(api, OP_UpdatePosition, params=params, data=data)
+
+@overload
+def GetAspects(api: SyncInvokerProtocol, documentNumber: str, buffer: bool) -> ResponseEnvelope[AspectDocument]: ...
+@overload
+def GetAspects(api: SyncRequestProtocol, documentNumber: str, buffer: bool) -> ResponseEnvelope[AspectDocument]: ...
+@overload
+def GetAspects(api: AsyncInvokerProtocol, documentNumber: str, buffer: bool) -> Awaitable[ResponseEnvelope[AspectDocument]]: ...
+@overload
+def GetAspects(api: AsyncRequestProtocol, documentNumber: str, buffer: bool) -> Awaitable[ResponseEnvelope[AspectDocument]]: ...
+def GetAspects(api: object, documentNumber: str, buffer: bool) -> ResponseEnvelope[AspectDocument] | Awaitable[ResponseEnvelope[AspectDocument]]:
+    params, data = _prepare_GetAspects(documentNumber=documentNumber, buffer=buffer)
+    return invoke_operation(api, OP_GetAspects, params=params, data=data)
+
+@overload
+def UpdateAspect(api: SyncInvokerProtocol, aspectPosition: "AspectPositionEdit") -> ResponseEnvelope[None]: ...
+@overload
+def UpdateAspect(api: SyncRequestProtocol, aspectPosition: "AspectPositionEdit") -> ResponseEnvelope[None]: ...
+@overload
+def UpdateAspect(api: AsyncInvokerProtocol, aspectPosition: "AspectPositionEdit") -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def UpdateAspect(api: AsyncRequestProtocol, aspectPosition: "AspectPositionEdit") -> Awaitable[ResponseEnvelope[None]]: ...
+def UpdateAspect(api: object, aspectPosition: "AspectPositionEdit") -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_UpdateAspect(aspectPosition=aspectPosition)
+    return invoke_operation(api, OP_UpdateAspect, params=params, data=data)
+
+__all__ = ["Get", "GetPositionsByDocumentId", "GetPositionsByDocumentNumber", "GetPosition", "Update", "UpdatePosition", "GetAspects", "UpdateAspect"]

SymfWebAPI/WebAPI/Interface/Sales/Interfaces/ISalesDimensionsController/_common.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any
+
+import json
+
+_REQUEST_Get = ('GET', '/api/SalesDimensions')
+def _prepare_Get(*, documentNumber, buffer) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentNumber"] = documentNumber
+    params["buffer"] = buffer
+    data = None
+    return params or None, data
+
+_REQUEST_GetPositionsByDocumentId = ('GET', '/api/SalesDimensions/Positions')
+def _prepare_GetPositionsByDocumentId(*, documentId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentId"] = documentId
+    data = None
+    return params or None, data
+
+_REQUEST_GetPositionsByDocumentNumber = ('GET', '/api/SalesDimensions/Positions')
+def _prepare_GetPositionsByDocumentNumber(*, documentNumber, buffer) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentNumber"] = documentNumber
+    params["buffer"] = buffer
+    data = None
+    return params or None, data
+
+_REQUEST_GetPosition = ('GET', '/api/SalesDimensions/Positions')
+def _prepare_GetPosition(*, positionId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["positionId"] = positionId
+    data = None
+    return params or None, data
+
+_REQUEST_Update = ('PUT', '/api/SalesDimensions/UpdateList')
+def _prepare_Update(*, documentNumber, buffer, documentDimensions) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentNumber"] = documentNumber
+    params["buffer"] = buffer
+    data = json.dumps(documentDimensions) if documentDimensions is not None else None
+    return params or None, data
+
+_REQUEST_UpdatePosition = ('PUT', '/api/SalesDimensions/UpdateMultiPositionsList')
+def _prepare_UpdatePosition(*, positionDimension) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = json.dumps(positionDimension) if positionDimension is not None else None
+    return params or None, data
+
+_REQUEST_GetAspects = ('GET', '/api/SalesDimensions/Aspects')
+def _prepare_GetAspects(*, documentNumber, buffer) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentNumber"] = documentNumber
+    params["buffer"] = buffer
+    data = None
+    return params or None, data
+
+_REQUEST_UpdateAspect = ('PUT', '/api/SalesDimensions/Aspects')
+def _prepare_UpdateAspect(*, aspectPosition) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = aspectPosition.model_dump_json(exclude_unset=True) if aspectPosition is not None else None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Sales/Interfaces/ISalesDimensionsController/_ops.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import List
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels.Aspects import AspectDocument
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels.Aspects import AspectPositionEdit
+from SymfWebAPI.WebAPI.Interface.FKF.Common.ViewModels import Dimension
+from SymfWebAPI.WebAPI.Interface.Common.ViewModels import PositionDimension
+
+_ADAPTER_Get = TypeAdapter(List[Dimension])
+
+def _parse_Get(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[Dimension]]:
+    return parse_with_adapter(envelope, _ADAPTER_Get)
+OP_Get = OperationSpec(method='GET', path='/api/SalesDimensions', parser=_parse_Get)
+
+_ADAPTER_GetPositionsByDocumentId = TypeAdapter(List[PositionDimension])
+
+def _parse_GetPositionsByDocumentId(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[PositionDimension]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetPositionsByDocumentId)
+OP_GetPositionsByDocumentId = OperationSpec(method='GET', path='/api/SalesDimensions/Positions', parser=_parse_GetPositionsByDocumentId)
+
+_ADAPTER_GetPositionsByDocumentNumber = TypeAdapter(List[PositionDimension])
+
+def _parse_GetPositionsByDocumentNumber(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[PositionDimension]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetPositionsByDocumentNumber)
+OP_GetPositionsByDocumentNumber = OperationSpec(method='GET', path='/api/SalesDimensions/Positions', parser=_parse_GetPositionsByDocumentNumber)
+
+_ADAPTER_GetPosition = TypeAdapter(List[Dimension])
+
+def _parse_GetPosition(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[Dimension]]:
+    return parse_with_adapter(envelope, _ADAPTER_GetPosition)
+OP_GetPosition = OperationSpec(method='GET', path='/api/SalesDimensions/Positions', parser=_parse_GetPosition)
+
+def _parse_Update(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_Update = OperationSpec(method='PUT', path='/api/SalesDimensions/UpdateList', parser=_parse_Update)
+
+def _parse_UpdatePosition(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_UpdatePosition = OperationSpec(method='PUT', path='/api/SalesDimensions/UpdateMultiPositionsList', parser=_parse_UpdatePosition)
+
+_ADAPTER_GetAspects = TypeAdapter(AspectDocument)
+
+def _parse_GetAspects(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[AspectDocument]:
+    return parse_with_adapter(envelope, _ADAPTER_GetAspects)
+OP_GetAspects = OperationSpec(method='GET', path='/api/SalesDimensions/Aspects', parser=_parse_GetAspects)
+
+def _parse_UpdateAspect(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_UpdateAspect = OperationSpec(method='PUT', path='/api/SalesDimensions/Aspects', parser=_parse_UpdateAspect)

SymfWebAPI/WebAPI/Interface/Sales/Interfaces/ISalesIssueController/__init__.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from typing import Awaitable, List, Optional, overload
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (AsyncInvokerProtocol, AsyncRequestProtocol, SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import AdvancePaymentOptions
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleCorrection
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels.CorrectionIssue.V2026_1 import SaleCorrectionIssue
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleDocument
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleDocumentWZ
+from ._common import (
+    _prepare_AddNew,
+    _prepare_Issue,
+    _prepare_IssueAdvancePayment,
+    _prepare_IssueWZ,
+    _prepare_IssueWZCorrection,
+    _prepare_ChangeDocumentNumber,
+    _prepare_IssuePN,
+    _prepare_ChangeFiscalStatus,
+)
+from ._ops import (
+    OP_AddNew,
+    OP_Issue,
+    OP_IssueAdvancePayment,
+    OP_IssueWZ,
+    OP_IssueWZCorrection,
+    OP_ChangeDocumentNumber,
+    OP_IssuePN,
+    OP_ChangeFiscalStatus,
+)
+
+@overload
+def AddNew(api: SyncInvokerProtocol, issue: bool, correction: "SaleCorrectionIssue") -> ResponseEnvelope[SaleCorrection]: ...
+@overload
+def AddNew(api: SyncRequestProtocol, issue: bool, correction: "SaleCorrectionIssue") -> ResponseEnvelope[SaleCorrection]: ...
+@overload
+def AddNew(api: AsyncInvokerProtocol, issue: bool, correction: "SaleCorrectionIssue") -> Awaitable[ResponseEnvelope[SaleCorrection]]: ...
+@overload
+def AddNew(api: AsyncRequestProtocol, issue: bool, correction: "SaleCorrectionIssue") -> Awaitable[ResponseEnvelope[SaleCorrection]]: ...
+def AddNew(api: object, issue: bool, correction: "SaleCorrectionIssue") -> ResponseEnvelope[SaleCorrection] | Awaitable[ResponseEnvelope[SaleCorrection]]:
+    params, data = _prepare_AddNew(issue=issue, correction=correction)
+    return invoke_operation(api, OP_AddNew, params=params, data=data)
+
+@overload
+def Issue(api: SyncInvokerProtocol, number: str) -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def Issue(api: SyncRequestProtocol, number: str) -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def Issue(api: AsyncInvokerProtocol, number: str) -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+@overload
+def Issue(api: AsyncRequestProtocol, number: str) -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+def Issue(api: object, number: str) -> ResponseEnvelope[SaleDocument] | Awaitable[ResponseEnvelope[SaleDocument]]:
+    params, data = _prepare_Issue(number=number)
+    return invoke_operation(api, OP_Issue, params=params, data=data)
+
+@overload
+def IssueAdvancePayment(api: SyncInvokerProtocol, documentNumber: str, options: "AdvancePaymentOptions") -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def IssueAdvancePayment(api: SyncRequestProtocol, documentNumber: str, options: "AdvancePaymentOptions") -> ResponseEnvelope[SaleDocument]: ...
+@overload
+def IssueAdvancePayment(api: AsyncInvokerProtocol, documentNumber: str, options: "AdvancePaymentOptions") -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+@overload
+def IssueAdvancePayment(api: AsyncRequestProtocol, documentNumber: str, options: "AdvancePaymentOptions") -> Awaitable[ResponseEnvelope[SaleDocument]]: ...
+def IssueAdvancePayment(api: object, documentNumber: str, options: "AdvancePaymentOptions") -> ResponseEnvelope[SaleDocument] | Awaitable[ResponseEnvelope[SaleDocument]]:
+    params, data = _prepare_IssueAdvancePayment(documentNumber=documentNumber, options=options)
+    return invoke_operation(api, OP_IssueAdvancePayment, params=params, data=data)
+
+@overload
+def IssueWZ(api: SyncInvokerProtocol, documentNumber: str, inBuffer: Optional[int] = None) -> ResponseEnvelope[List[SaleDocumentWZ]]: ...
+@overload
+def IssueWZ(api: SyncRequestProtocol, documentNumber: str, inBuffer: Optional[int] = None) -> ResponseEnvelope[List[SaleDocumentWZ]]: ...
+@overload
+def IssueWZ(api: AsyncInvokerProtocol, documentNumber: str, inBuffer: Optional[int] = None) -> Awaitable[ResponseEnvelope[List[SaleDocumentWZ]]]: ...
+@overload
+def IssueWZ(api: AsyncRequestProtocol, documentNumber: str, inBuffer: Optional[int] = None) -> Awaitable[ResponseEnvelope[List[SaleDocumentWZ]]]: ...
+def IssueWZ(api: object, documentNumber: str, inBuffer: Optional[int] = None) -> ResponseEnvelope[List[SaleDocumentWZ]] | Awaitable[ResponseEnvelope[List[SaleDocumentWZ]]]:
+    params, data = _prepare_IssueWZ(documentNumber=documentNumber, inBuffer=inBuffer)
+    return invoke_operation(api, OP_IssueWZ, params=params, data=data)
+
+@overload
+def IssueWZCorrection(api: SyncInvokerProtocol, documentNumber: str, issue: bool) -> ResponseEnvelope[List[SaleDocumentWZ]]: ...
+@overload
+def IssueWZCorrection(api: SyncRequestProtocol, documentNumber: str, issue: bool) -> ResponseEnvelope[List[SaleDocumentWZ]]: ...
+@overload
+def IssueWZCorrection(api: AsyncInvokerProtocol, documentNumber: str, issue: bool) -> Awaitable[ResponseEnvelope[List[SaleDocumentWZ]]]: ...
+@overload
+def IssueWZCorrection(api: AsyncRequestProtocol, documentNumber: str, issue: bool) -> Awaitable[ResponseEnvelope[List[SaleDocumentWZ]]]: ...
+def IssueWZCorrection(api: object, documentNumber: str, issue: bool) -> ResponseEnvelope[List[SaleDocumentWZ]] | Awaitable[ResponseEnvelope[List[SaleDocumentWZ]]]:
+    params, data = _prepare_IssueWZCorrection(documentNumber=documentNumber, issue=issue)
+    return invoke_operation(api, OP_IssueWZCorrection, params=params, data=data)
+
+@overload
+def ChangeDocumentNumber(api: SyncInvokerProtocol, id: int, number: str) -> ResponseEnvelope[None]: ...
+@overload
+def ChangeDocumentNumber(api: SyncRequestProtocol, id: int, number: str) -> ResponseEnvelope[None]: ...
+@overload
+def ChangeDocumentNumber(api: AsyncInvokerProtocol, id: int, number: str) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def ChangeDocumentNumber(api: AsyncRequestProtocol, id: int, number: str) -> Awaitable[ResponseEnvelope[None]]: ...
+def ChangeDocumentNumber(api: object, id: int, number: str) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_ChangeDocumentNumber(id=id, number=number)
+    return invoke_operation(api, OP_ChangeDocumentNumber, params=params, data=data)
+
+@overload
+def IssuePN(api: SyncInvokerProtocol, documentNumber: str) -> ResponseEnvelope[None]: ...
+@overload
+def IssuePN(api: SyncRequestProtocol, documentNumber: str) -> ResponseEnvelope[None]: ...
+@overload
+def IssuePN(api: AsyncInvokerProtocol, documentNumber: str) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def IssuePN(api: AsyncRequestProtocol, documentNumber: str) -> Awaitable[ResponseEnvelope[None]]: ...
+def IssuePN(api: object, documentNumber: str) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_IssuePN(documentNumber=documentNumber)
+    return invoke_operation(api, OP_IssuePN, params=params, data=data)
+
+@overload
+def ChangeFiscalStatus(api: SyncInvokerProtocol, documentNumber: str) -> ResponseEnvelope[None]: ...
+@overload
+def ChangeFiscalStatus(api: SyncRequestProtocol, documentNumber: str) -> ResponseEnvelope[None]: ...
+@overload
+def ChangeFiscalStatus(api: AsyncInvokerProtocol, documentNumber: str) -> Awaitable[ResponseEnvelope[None]]: ...
+@overload
+def ChangeFiscalStatus(api: AsyncRequestProtocol, documentNumber: str) -> Awaitable[ResponseEnvelope[None]]: ...
+def ChangeFiscalStatus(api: object, documentNumber: str) -> ResponseEnvelope[None] | Awaitable[ResponseEnvelope[None]]:
+    params, data = _prepare_ChangeFiscalStatus(documentNumber=documentNumber)
+    return invoke_operation(api, OP_ChangeFiscalStatus, params=params, data=data)
+
+__all__ = ["AddNew", "Issue", "IssueAdvancePayment", "IssueWZ", "IssueWZCorrection", "ChangeDocumentNumber", "IssuePN", "ChangeFiscalStatus"]

SymfWebAPI/WebAPI/Interface/Sales/Interfaces/ISalesIssueController/_common.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any
+
+_REQUEST_AddNew = ('POST', '/api/SalesIssue/NewCorrection')
+def _prepare_AddNew(*, issue, correction) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["issue"] = issue
+    data = correction.model_dump_json(exclude_unset=True) if correction is not None else None
+    return params or None, data
+
+_REQUEST_Issue = ('PUT', '/api/SalesIssue/InBuffer')
+def _prepare_Issue(*, number) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["number"] = number
+    data = None
+    return params or None, data
+
+_REQUEST_IssueAdvancePayment = ('PUT', '/api/SalesIssue/AdvancePayment')
+def _prepare_IssueAdvancePayment(*, documentNumber, options) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentNumber"] = documentNumber
+    data = options.model_dump_json(exclude_unset=True) if options is not None else None
+    return params or None, data
+
+_REQUEST_IssueWZ = ('PUT', '/api/SalesIssue/WZ')
+def _prepare_IssueWZ(*, documentNumber, inBuffer = None) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentNumber"] = documentNumber
+    if inBuffer is not None:
+        params["inBuffer"] = inBuffer
+    data = None
+    return params or None, data
+
+_REQUEST_IssueWZCorrection = ('PUT', '/api/SalesIssue/IssueWZCorrection')
+def _prepare_IssueWZCorrection(*, documentNumber, issue) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentNumber"] = documentNumber
+    params["issue"] = issue
+    data = None
+    return params or None, data
+
+_REQUEST_ChangeDocumentNumber = ('PATCH', '/api/SalesIssue/DocumentNumber')
+def _prepare_ChangeDocumentNumber(*, id, number) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    params["number"] = number
+    data = None
+    return params or None, data
+
+_REQUEST_IssuePN = ('PUT', '/api/SalesIssue/IssuePayment')
+def _prepare_IssuePN(*, documentNumber) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentNumber"] = documentNumber
+    data = None
+    return params or None, data
+
+_REQUEST_ChangeFiscalStatus = ('PATCH', '/api/SalesIssue/FiscalStatus')
+def _prepare_ChangeFiscalStatus(*, documentNumber) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["documentNumber"] = documentNumber
+    data = None
+    return params or None, data

SymfWebAPI/WebAPI/Interface/Sales/Interfaces/ISalesIssueController/_ops.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import List, Optional
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import OperationSpec, parse_none, parse_with_adapter
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import AdvancePaymentOptions
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleCorrection
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels.CorrectionIssue.V2026_1 import SaleCorrectionIssue
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleDocument
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import SaleDocumentWZ
+
+_ADAPTER_AddNew = TypeAdapter(SaleCorrection)
+
+def _parse_AddNew(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[SaleCorrection]:
+    return parse_with_adapter(envelope, _ADAPTER_AddNew)
+OP_AddNew = OperationSpec(method='POST', path='/api/SalesIssue/NewCorrection', parser=_parse_AddNew)
+
+_ADAPTER_Issue = TypeAdapter(SaleDocument)
+
+def _parse_Issue(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[SaleDocument]:
+    return parse_with_adapter(envelope, _ADAPTER_Issue)
+OP_Issue = OperationSpec(method='PUT', path='/api/SalesIssue/InBuffer', parser=_parse_Issue)
+
+_ADAPTER_IssueAdvancePayment = TypeAdapter(SaleDocument)
+
+def _parse_IssueAdvancePayment(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[SaleDocument]:
+    return parse_with_adapter(envelope, _ADAPTER_IssueAdvancePayment)
+OP_IssueAdvancePayment = OperationSpec(method='PUT', path='/api/SalesIssue/AdvancePayment', parser=_parse_IssueAdvancePayment)
+
+_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/SalesIssue/WZ', parser=_parse_IssueWZ)
+
+_ADAPTER_IssueWZCorrection = TypeAdapter(List[SaleDocumentWZ])
+
+def _parse_IssueWZCorrection(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[List[SaleDocumentWZ]]:
+    return parse_with_adapter(envelope, _ADAPTER_IssueWZCorrection)
+OP_IssueWZCorrection = OperationSpec(method='PUT', path='/api/SalesIssue/IssueWZCorrection', parser=_parse_IssueWZCorrection)
+
+def _parse_ChangeDocumentNumber(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_ChangeDocumentNumber = OperationSpec(method='PATCH', path='/api/SalesIssue/DocumentNumber', parser=_parse_ChangeDocumentNumber)
+
+def _parse_IssuePN(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_IssuePN = OperationSpec(method='PUT', path='/api/SalesIssue/IssuePayment', parser=_parse_IssuePN)
+
+def _parse_ChangeFiscalStatus(envelope: ResponseEnvelope[object]) -> ResponseEnvelope[None]:
+    return parse_none(envelope)
+OP_ChangeFiscalStatus = OperationSpec(method='PATCH', path='/api/SalesIssue/FiscalStatus', parser=_parse_ChangeFiscalStatus)

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

@@ -0,0 +1,25 @@
+"""Auto-generated package (lazy imports)."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+__all__ = ("IFiscalPrinterController", "ISalesController", "ISalesDimensions2Controller", "ISalesDimensionsController", "ISalesIssueController",)
+
+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 IFiscalPrinterController as _IFiscalPrinterController
+    from . import ISalesController as _ISalesController
+    from . import ISalesDimensions2Controller as _ISalesDimensions2Controller
+    from . import ISalesDimensionsController as _ISalesDimensionsController
+    from . import ISalesIssueController as _ISalesIssueController

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

@@ -0,0 +1,42 @@
+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 enumJPK_V7DocumentAttribute
+from SymfWebAPI.WebAPI.Interface.Sales.ViewModels import (
+    SaleCorrectionIssueContractor,
+    SaleCorrectionIssuePosition,
+    SaleDocumentIssueCatalog,
+    SaleDocumentIssueKind,
+)
+
+class SaleCorrectionIssue(BaseModel):
+    ThirdPartyContractor: "SaleCorrectionIssueContractor"
+    MasterDocumentId: Optional[int]
+    MasterDocumentNumber: str
+    TypeCode: str
+    Series: str
+    NumberInSeries: Optional[int]
+    SplitPayment: bool
+    JPK_V7Attributes: Optional["enumJPK_V7DocumentAttribute"]
+    Buyer: "SaleCorrectionIssueContractor"
+    Recipient: "SaleCorrectionIssueContractor"
+    PaymentRegistry: "PaymentRegistryBase"
+    PaymentFormId: Optional[int]
+    IssueDate: Optional[datetime]
+    SaleDate: Optional[datetime]
+    MaturityDate: Optional[datetime]
+    CurrencyRate: Optional[Decimal]
+    Positions: List["SaleCorrectionIssuePosition"]
+    Catalog: "SaleDocumentIssueCatalog"
+    Kind: "SaleDocumentIssueKind"
+    Marker: int
+    ReceivedBy: str
+    CorrectionReason: str
+    Note: str
+    DocumentExternalMetadata: str
+    IsSmeProcedure: bool

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

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+_VERSIONED_EXPORTS = {
+    'SaleCorrectionIssue': '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 SaleCorrectionIssue

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

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from typing import Optional
+from datetime import datetime
+from decimal import Decimal
+
+class DocumentIssueSettlement(BaseModel):
+    SettlementDate: Optional[datetime]
+    Value: Decimal