redblack-python-sdk 0.1.0__py3-none-any.whl

redblack/resources/review_sets.py

@@ -0,0 +1,889 @@
+"""Review-set reads, order-add sessions, and order-release sessions."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Mapping, Sequence
+from dataclasses import dataclass
+from threading import Event
+from typing import Any, Literal, overload
+
+from ..models import (
+    OrderAddCancelResult,
+    OrderAddResult,
+    OrderAddSession,
+    OrderAddSessionItem,
+    OrderCreate,
+    OrderCreateResult,
+    PendingOrder,
+    ReleaseError,
+    ReleaseValidationResult,
+    ReviewSet,
+    ReviewSetReleaseSession,
+)
+from ..models.generated import (
+    ReviewSetsCancelReleaseResponse200,
+    ReviewSetsCancelReleaseResponse202,
+)
+from ..odata import DEFAULT_PAGE_SIZE, ODataQuery
+from ..pagination import Page, Paginator
+from ..polling import Poller, PollOutcome
+from ._base import (
+    ApiResponseProtocol,
+    ClientProtocol,
+    HttpInfoMode,
+    Resource,
+    body_mapping,
+    body_value,
+    enum_value,
+    read_member,
+    require_positive_identifier,
+)
+from ._exports import WorkflowProtocolError
+
+
+def _optional_boolean(name: str, value: bool | None) -> None:
+    if value is not None and not isinstance(value, bool):
+        raise TypeError(f"{name} must be a boolean")
+
+
+def _set_optional_boolean(body: dict[str, Any], wire_name: str, value: bool | None) -> None:
+    _optional_boolean(wire_name, value)
+    if value is None:
+        return
+    if wire_name in body and body[wire_name] != value:
+        raise ValueError(f"{wire_name} conflicts with the request body")
+    body[wire_name] = value
+
+
+def _validate_versioned_id(value: object) -> dict[str, int]:
+    item = body_mapping(value)
+    identifier = item.get("id")
+    row_version = item.get("rowVersion", item.get("row_version"))
+    if isinstance(identifier, bool) or not isinstance(identifier, int):
+        raise TypeError("order id must be an integer")
+    require_positive_identifier("order id", identifier)
+    if isinstance(row_version, bool) or not isinstance(row_version, int):
+        raise TypeError("rowVersion must be an integer")
+    if row_version < 0:
+        raise ValueError("rowVersion must be greater than or equal to zero")
+    return {"id": identifier, "rowVersion": row_version}
+
+
+@dataclass(frozen=True, slots=True)
+class ReleaseCriteria:
+    """Validated release target selection using RedBlack FilterMode values."""
+
+    mode: int
+    filter: str | None = None
+    ids: tuple[object, ...] | None = None
+
+    def __post_init__(self) -> None:
+        if isinstance(self.mode, bool) or not isinstance(self.mode, int):
+            raise TypeError("release criteria mode must be an integer")
+        if self.mode not in {0, 1, 2}:
+            raise ValueError("release criteria mode must be 0, 1, or 2")
+        if self.mode == 0:
+            if not isinstance(self.filter, str) or not self.filter.strip():
+                raise ValueError("Filtered release criteria requires a filter")
+            if self.ids is not None:
+                raise ValueError("Filtered release criteria must not include ids")
+        elif self.mode == 1:
+            if self.filter is not None:
+                raise ValueError("Specific release criteria must not include a filter")
+            if not self.ids:
+                raise ValueError("Specific release criteria requires ids")
+            if len(self.ids) > 500:
+                raise ValueError("Specific release criteria is limited to 500 ids")
+            for item in self.ids:
+                _validate_versioned_id(item)
+        elif self.filter is not None or self.ids is not None:
+            raise ValueError("All release criteria must not include filter or ids")
+
+    @classmethod
+    def filtered(cls, filter: str) -> ReleaseCriteria:
+        return cls(mode=0, filter=filter)
+
+    @classmethod
+    def specific(cls, ids: Sequence[object]) -> ReleaseCriteria:
+        return cls(mode=1, ids=tuple(ids))
+
+    @classmethod
+    def all(cls) -> ReleaseCriteria:
+        """Explicitly target all pending orders in the review set."""
+
+        return cls(mode=2)
+
+    def to_wire(self) -> dict[str, Any]:
+        if self.mode == 0:
+            return {"mode": 0, "filter": self.filter, "ids": None}
+        if self.mode == 1:
+            return {
+                "mode": 1,
+                "filter": None,
+                "ids": [_validate_versioned_id(item) for item in self.ids or ()],
+            }
+        return {"mode": 2, "filter": None, "ids": None}
+
+
+def _normalize_criteria(value: ReleaseCriteria | Mapping[str, object]) -> dict[str, Any]:
+    if isinstance(value, ReleaseCriteria):
+        return value.to_wire()
+    body = body_mapping(value)
+    raw_mode = body.get("mode")
+    if isinstance(raw_mode, bool) or not isinstance(raw_mode, int):
+        raise TypeError("release criteria mode must be an integer")
+    raw_ids = body.get("ids")
+    ids: tuple[object, ...] | None
+    if raw_ids is None:
+        ids = None
+    elif isinstance(raw_ids, Sequence) and not isinstance(raw_ids, str | bytes | bytearray):
+        ids = tuple(raw_ids)
+    else:
+        raise TypeError("release criteria ids must be a sequence")
+    return ReleaseCriteria(
+        mode=raw_mode,
+        filter=body.get("filter"),
+        ids=ids,
+    ).to_wire()
+
+
+@dataclass(slots=True)
+class OrderAddSessionHandle:
+    _client: ClientProtocol
+    review_set_id: int
+    session_id: int
+    latest: OrderAddSession | None = None
+
+    def __post_init__(self) -> None:
+        require_positive_identifier("review_set_id", self.review_set_id)
+        require_positive_identifier("session_id", self.session_id)
+
+    @property
+    def _path(self) -> dict[str, int]:
+        return {
+            "reviewSetId": self.review_set_id,
+            "sessionId": self.session_id,
+        }
+
+    def _refresh_with_timeout(self, timeout_budget: float | None) -> OrderAddSession:
+        if timeout_budget is None:
+            return self.refresh()
+        response = self._client.request(
+            "ReviewSets_GetOrderAddSession",
+            path_params=self._path,
+            timeout_budget=timeout_budget,
+        )
+        self.latest = response.data
+        return response.data
+
+    def refresh(self) -> OrderAddSession:
+        response = self._client.request("ReviewSets_GetOrderAddSession", path_params=self._path)
+        self.latest = response.data
+        return response.data
+
+    status = refresh
+
+    @staticmethod
+    def _classify(value: object) -> PollOutcome:
+        status = enum_value(value, "session_status", "sessionStatus")
+        if status == 3:
+            return PollOutcome.SUCCEEDED
+        if status == 19:
+            return PollOutcome.NEEDS_INPUT
+        if status in {4, 5, 20}:
+            return PollOutcome.FAILED
+        return PollOutcome.PENDING
+
+    def wait(
+        self,
+        *,
+        timeout: float | None = 300.0,
+        poll_interval: float = 1.0,
+        max_interval: float = 30.0,
+        stop_event: Event | None = None,
+        raise_on_failure: bool = True,
+    ) -> OrderAddSession:
+        return Poller(
+            refresh=self.refresh,
+            classify=self._classify,
+            refresh_with_timeout=self._refresh_with_timeout,
+        ).wait(
+            timeout=timeout,
+            poll_interval=poll_interval,
+            max_interval=max_interval,
+            stop_event=stop_event,
+            raise_on_failure=raise_on_failure,
+        )
+
+    def results(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[OrderAddResult]:
+        query = ODataQuery(filter=filter, order_by=order_by, top=top, skip=skip, count=count)
+        response = self._client.request(
+            "ReviewSets_QueryOrderAddSessionResults",
+            path_params=self._path,
+            query=query.to_params(),
+        )
+        return Page.from_data(response.data, query=query, http=response.http)
+
+    def iter_results(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        count: bool | None = None,
+        start_skip: int = 0,
+        page_size: int = DEFAULT_PAGE_SIZE,
+        max_items: int | None = None,
+    ) -> Iterator[OrderAddResult]:
+        base = ODataQuery(filter=filter, order_by=order_by, count=count, skip=start_skip)
+        return Paginator(
+            fetch_page=lambda query: self.results(
+                filter=query.filter,
+                order_by=query.order_by,
+                top=query.top,
+                skip=query.skip,
+                count=query.count,
+            ),
+            query=base,
+            page_size=page_size,
+            max_items=max_items,
+        ).iter_items()
+
+    def cancel(self) -> OrderAddCancelResult:
+        response = self._client.request("ReviewSets_CancelOrderAddSession", path_params=self._path)
+        return response.data
+
+    @property
+    def has_failures(self) -> bool:
+        error_count = read_member(self.latest, "error_count", "errorCount")
+        return (
+            isinstance(error_count, int) and not isinstance(error_count, bool) and error_count > 0
+        )
+
+
+@dataclass(slots=True)
+class ReleaseSessionHandle:
+    _client: ClientProtocol
+    review_set_id: int
+    session_id: int
+    latest: object | None = None
+
+    def __post_init__(self) -> None:
+        require_positive_identifier("review_set_id", self.review_set_id)
+        require_positive_identifier("session_id", self.session_id)
+
+    @property
+    def _path(self) -> dict[str, int]:
+        return {
+            "reviewSetId": self.review_set_id,
+            "sessionId": self.session_id,
+        }
+
+    def _refresh_with_timeout(self, timeout_budget: float | None) -> ReviewSetReleaseSession:
+        if timeout_budget is None:
+            return self.refresh()
+        response = self._client.request(
+            "ReviewSets_GetReleaseSession",
+            path_params=self._path,
+            timeout_budget=timeout_budget,
+        )
+        self.latest = response.data
+        return response.data
+
+    def refresh(self) -> ReviewSetReleaseSession:
+        response = self._client.request("ReviewSets_GetReleaseSession", path_params=self._path)
+        self.latest = response.data
+        return response.data
+
+    status = refresh
+
+    @staticmethod
+    def _classify(value: object) -> PollOutcome:
+        status = enum_value(value, "session_status", "sessionStatus")
+        if status == 5:
+            return PollOutcome.SUCCEEDED
+        if status in {6, 7}:
+            return PollOutcome.FAILED
+        return PollOutcome.PENDING
+
+    def wait(
+        self,
+        *,
+        timeout: float | None = 300.0,
+        poll_interval: float = 1.0,
+        max_interval: float = 30.0,
+        stop_event: Event | None = None,
+        raise_on_failure: bool = True,
+    ) -> ReviewSetReleaseSession:
+        return Poller(
+            refresh=self.refresh,
+            classify=self._classify,
+            refresh_with_timeout=self._refresh_with_timeout,
+        ).wait(
+            timeout=timeout,
+            poll_interval=poll_interval,
+            max_interval=max_interval,
+            stop_event=stop_event,
+            raise_on_failure=raise_on_failure,
+        )
+
+    def validation_results(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[ReleaseValidationResult]:
+        query = ODataQuery(filter=filter, order_by=order_by, top=top, skip=skip, count=count)
+        response = self._client.request(
+            "ReviewSets_QueryReleaseValidationResults",
+            path_params=self._path,
+            query=query.to_params(),
+        )
+        return Page.from_data(response.data, query=query, http=response.http)
+
+    def errors(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[ReleaseError]:
+        query = ODataQuery(filter=filter, order_by=order_by, top=top, skip=skip, count=count)
+        response = self._client.request(
+            "ReviewSets_QueryReleaseResults",
+            path_params=self._path,
+            query=query.to_params(),
+        )
+        # The documented 204 success deliberately becomes an empty Page.
+        return Page.from_data(response.data, query=query, http=response.http)
+
+    def cancel(
+        self,
+    ) -> ReviewSetsCancelReleaseResponse200 | ReviewSetsCancelReleaseResponse202:
+        response = self._client.request("ReviewSets_CancelRelease", path_params=self._path)
+        self.latest = response.data
+        return response.data
+
+    @property
+    def has_failures(self) -> bool:
+        stats = read_member(self.latest, "release_stats", "releaseStats")
+        failed = read_member(stats, "failed")
+        return isinstance(failed, int) and not isinstance(failed, bool) and failed > 0
+
+
+class ReviewSetsResource(Resource[HttpInfoMode]):
+    OPERATION_IDS = frozenset(
+        {
+            "ReviewSets_Query",
+            "ReviewSetsPendingOrders_Query",
+            "ReviewSets_CreateOrder",
+            "ReviewSets_CreateOrderAddSession",
+            "ReviewSets_GetOrderAddSession",
+            "ReviewSets_QueryOrderAddSessionResults",
+            "ReviewSets_CancelOrderAddSession",
+            "ReviewSets_ReleaseOrders",
+            "ReviewSets_GetReleaseSession",
+            "ReviewSets_QueryReleaseValidationResults",
+            "ReviewSets_QueryReleaseResults",
+            "ReviewSets_CancelRelease",
+        }
+    )
+
+    def _collection(
+        self,
+        operation_id: str,
+        *,
+        path_params: Mapping[str, object] | None = None,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[Any] | ApiResponseProtocol[Page[Any]]:
+        return self._page(
+            operation_id,
+            path_params=path_params,
+            odata=ODataQuery(
+                filter=filter,
+                order_by=order_by,
+                top=top,
+                skip=skip,
+                count=count,
+            ),
+        )
+
+    @overload
+    def list(
+        self: ReviewSetsResource[Literal[False]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[ReviewSet]: ...
+
+    @overload
+    def list(
+        self: ReviewSetsResource[Literal[True]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> ApiResponseProtocol[Page[ReviewSet]]: ...
+
+    def list(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[ReviewSet] | ApiResponseProtocol[Page[ReviewSet]]:
+        return self._collection(
+            "ReviewSets_Query",
+            filter=filter,
+            order_by=order_by,
+            top=top,
+            skip=skip,
+            count=count,
+        )
+
+    @overload
+    def list_pending_orders(
+        self: ReviewSetsResource[Literal[False]],
+        review_set_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[PendingOrder]: ...
+
+    @overload
+    def list_pending_orders(
+        self: ReviewSetsResource[Literal[True]],
+        review_set_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> ApiResponseProtocol[Page[PendingOrder]]: ...
+
+    def list_pending_orders(
+        self,
+        review_set_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[PendingOrder] | ApiResponseProtocol[Page[PendingOrder]]:
+        require_positive_identifier("review_set_id", review_set_id)
+        return self._collection(
+            "ReviewSetsPendingOrders_Query",
+            path_params={"reviewSetId": review_set_id},
+            filter=filter,
+            order_by=order_by,
+            top=top,
+            skip=skip,
+            count=count,
+        )
+
+    @overload
+    def create_order(
+        self: ReviewSetsResource[Literal[False]],
+        review_set_id: int,
+        order: OrderCreate | Mapping[str, object],
+        *,
+        ignore_warnings: bool | None = None,
+    ) -> OrderCreateResult: ...
+
+    @overload
+    def create_order(
+        self: ReviewSetsResource[Literal[True]],
+        review_set_id: int,
+        order: OrderCreate | Mapping[str, object],
+        *,
+        ignore_warnings: bool | None = None,
+    ) -> ApiResponseProtocol[OrderCreateResult]: ...
+
+    def create_order(
+        self,
+        review_set_id: int,
+        order: OrderCreate | Mapping[str, object],
+        *,
+        ignore_warnings: bool | None = None,
+    ) -> OrderCreateResult | ApiResponseProtocol[OrderCreateResult]:
+        require_positive_identifier("review_set_id", review_set_id)
+        payload = body_mapping(order)
+        _set_optional_boolean(payload, "ignoreWarnings", ignore_warnings)
+        response = self._request(
+            "ReviewSets_CreateOrder",
+            path_params={"reviewSetId": review_set_id},
+            json=payload,
+        )
+        return self._finish(response, response.data)
+
+    @overload
+    def start_order_add(
+        self: ReviewSetsResource[Literal[False]],
+        review_set_id: int,
+        orders: Sequence[OrderAddSessionItem | Mapping[str, object]],
+        *,
+        ignore_warnings: bool | None = None,
+    ) -> OrderAddSessionHandle: ...
+
+    @overload
+    def start_order_add(
+        self: ReviewSetsResource[Literal[True]],
+        review_set_id: int,
+        orders: Sequence[OrderAddSessionItem | Mapping[str, object]],
+        *,
+        ignore_warnings: bool | None = None,
+    ) -> ApiResponseProtocol[OrderAddSessionHandle]: ...
+
+    def start_order_add(
+        self,
+        review_set_id: int,
+        orders: Sequence[OrderAddSessionItem | Mapping[str, object]],
+        *,
+        ignore_warnings: bool | None = None,
+    ) -> OrderAddSessionHandle | ApiResponseProtocol[OrderAddSessionHandle]:
+        require_positive_identifier("review_set_id", review_set_id)
+        if isinstance(orders, str | bytes | bytearray):
+            raise TypeError("orders must be a sequence of order requests")
+        order_values = list(orders)
+        if not 1 <= len(order_values) <= 500:
+            raise ValueError("orders must contain between 1 and 500 entries")
+        payload: dict[str, Any] = {"orders": [body_value(order) for order in order_values]}
+        _set_optional_boolean(payload, "ignoreWarnings", ignore_warnings)
+        response = self._request(
+            "ReviewSets_CreateOrderAddSession",
+            path_params={"reviewSetId": review_set_id},
+            json=payload,
+        )
+        session_id = read_member(response.data, "id")
+        if isinstance(session_id, bool) or not isinstance(session_id, int):
+            raise WorkflowProtocolError("order-add create response omitted integer id")
+        handle = OrderAddSessionHandle(
+            self._client,
+            review_set_id,
+            session_id,
+            latest=response.data,
+        )
+        return self._finish(response, handle)
+
+    @overload
+    def get_order_add_session(
+        self: ReviewSetsResource[Literal[False]], review_set_id: int, session_id: int
+    ) -> OrderAddSessionHandle: ...
+
+    @overload
+    def get_order_add_session(
+        self: ReviewSetsResource[Literal[True]], review_set_id: int, session_id: int
+    ) -> ApiResponseProtocol[OrderAddSessionHandle]: ...
+
+    def get_order_add_session(
+        self, review_set_id: int, session_id: int
+    ) -> OrderAddSessionHandle | ApiResponseProtocol[OrderAddSessionHandle]:
+        require_positive_identifier("review_set_id", review_set_id)
+        require_positive_identifier("session_id", session_id)
+        response = self._request(
+            "ReviewSets_GetOrderAddSession",
+            path_params={"reviewSetId": review_set_id, "sessionId": session_id},
+        )
+        handle = OrderAddSessionHandle(
+            self._client, review_set_id, session_id, latest=response.data
+        )
+        return self._finish(response, handle)
+
+    @overload
+    def list_order_add_results(
+        self: ReviewSetsResource[Literal[False]],
+        review_set_id: int,
+        session_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[OrderAddResult]: ...
+
+    @overload
+    def list_order_add_results(
+        self: ReviewSetsResource[Literal[True]],
+        review_set_id: int,
+        session_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> ApiResponseProtocol[Page[OrderAddResult]]: ...
+
+    def list_order_add_results(
+        self,
+        review_set_id: int,
+        session_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[OrderAddResult] | ApiResponseProtocol[Page[OrderAddResult]]:
+        require_positive_identifier("review_set_id", review_set_id)
+        require_positive_identifier("session_id", session_id)
+        return self._collection(
+            "ReviewSets_QueryOrderAddSessionResults",
+            path_params={"reviewSetId": review_set_id, "sessionId": session_id},
+            filter=filter,
+            order_by=order_by,
+            top=top,
+            skip=skip,
+            count=count,
+        )
+
+    @overload
+    def cancel_order_add_session(
+        self: ReviewSetsResource[Literal[False]], review_set_id: int, session_id: int
+    ) -> OrderAddCancelResult: ...
+
+    @overload
+    def cancel_order_add_session(
+        self: ReviewSetsResource[Literal[True]], review_set_id: int, session_id: int
+    ) -> ApiResponseProtocol[OrderAddCancelResult]: ...
+
+    def cancel_order_add_session(
+        self, review_set_id: int, session_id: int
+    ) -> OrderAddCancelResult | ApiResponseProtocol[OrderAddCancelResult]:
+        require_positive_identifier("review_set_id", review_set_id)
+        require_positive_identifier("session_id", session_id)
+        response = self._request(
+            "ReviewSets_CancelOrderAddSession",
+            path_params={"reviewSetId": review_set_id, "sessionId": session_id},
+        )
+        return self._finish(response, response.data)
+
+    @overload
+    def start_release(
+        self: ReviewSetsResource[Literal[False]],
+        review_set_id: int,
+        *,
+        criteria: ReleaseCriteria | Mapping[str, object],
+        skip_validation: bool | None = None,
+        ignore_approval_warnings: bool | None = None,
+        allow_partial_release: bool | None = None,
+    ) -> ReleaseSessionHandle: ...
+
+    @overload
+    def start_release(
+        self: ReviewSetsResource[Literal[True]],
+        review_set_id: int,
+        *,
+        criteria: ReleaseCriteria | Mapping[str, object],
+        skip_validation: bool | None = None,
+        ignore_approval_warnings: bool | None = None,
+        allow_partial_release: bool | None = None,
+    ) -> ApiResponseProtocol[ReleaseSessionHandle]: ...
+
+    def start_release(
+        self,
+        review_set_id: int,
+        *,
+        criteria: ReleaseCriteria | Mapping[str, object],
+        skip_validation: bool | None = None,
+        ignore_approval_warnings: bool | None = None,
+        allow_partial_release: bool | None = None,
+    ) -> ReleaseSessionHandle | ApiResponseProtocol[ReleaseSessionHandle]:
+        require_positive_identifier("review_set_id", review_set_id)
+        payload: dict[str, Any] = {"criteria": _normalize_criteria(criteria)}
+        _set_optional_boolean(payload, "skipValidation", skip_validation)
+        _set_optional_boolean(payload, "ignoreApprovalWarnings", ignore_approval_warnings)
+        _set_optional_boolean(payload, "allowPartialRelease", allow_partial_release)
+        response = self._request(
+            "ReviewSets_ReleaseOrders",
+            path_params={"reviewSetId": review_set_id},
+            json=payload,
+        )
+        session_id = read_member(response.data, "id")
+        if isinstance(session_id, bool) or not isinstance(session_id, int):
+            raise WorkflowProtocolError("release create response omitted integer id")
+        handle = ReleaseSessionHandle(
+            self._client,
+            review_set_id,
+            session_id,
+            latest=response.data,
+        )
+        return self._finish(response, handle)
+
+    @overload
+    def get_release_session(
+        self: ReviewSetsResource[Literal[False]], review_set_id: int, session_id: int
+    ) -> ReleaseSessionHandle: ...
+
+    @overload
+    def get_release_session(
+        self: ReviewSetsResource[Literal[True]], review_set_id: int, session_id: int
+    ) -> ApiResponseProtocol[ReleaseSessionHandle]: ...
+
+    def get_release_session(
+        self, review_set_id: int, session_id: int
+    ) -> ReleaseSessionHandle | ApiResponseProtocol[ReleaseSessionHandle]:
+        require_positive_identifier("review_set_id", review_set_id)
+        require_positive_identifier("session_id", session_id)
+        response = self._request(
+            "ReviewSets_GetReleaseSession",
+            path_params={"reviewSetId": review_set_id, "sessionId": session_id},
+        )
+        handle = ReleaseSessionHandle(self._client, review_set_id, session_id, latest=response.data)
+        return self._finish(response, handle)
+
+    @overload
+    def list_release_validation_results(
+        self: ReviewSetsResource[Literal[False]],
+        review_set_id: int,
+        session_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[ReleaseValidationResult]: ...
+
+    @overload
+    def list_release_validation_results(
+        self: ReviewSetsResource[Literal[True]],
+        review_set_id: int,
+        session_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> ApiResponseProtocol[Page[ReleaseValidationResult]]: ...
+
+    def list_release_validation_results(
+        self,
+        review_set_id: int,
+        session_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[ReleaseValidationResult] | ApiResponseProtocol[Page[ReleaseValidationResult]]:
+        require_positive_identifier("review_set_id", review_set_id)
+        require_positive_identifier("session_id", session_id)
+        return self._collection(
+            "ReviewSets_QueryReleaseValidationResults",
+            path_params={"reviewSetId": review_set_id, "sessionId": session_id},
+            filter=filter,
+            order_by=order_by,
+            top=top,
+            skip=skip,
+            count=count,
+        )
+
+    @overload
+    def list_release_errors(
+        self: ReviewSetsResource[Literal[False]],
+        review_set_id: int,
+        session_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[ReleaseError]: ...
+
+    @overload
+    def list_release_errors(
+        self: ReviewSetsResource[Literal[True]],
+        review_set_id: int,
+        session_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> ApiResponseProtocol[Page[ReleaseError]]: ...
+
+    def list_release_errors(
+        self,
+        review_set_id: int,
+        session_id: int,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[ReleaseError] | ApiResponseProtocol[Page[ReleaseError]]:
+        require_positive_identifier("review_set_id", review_set_id)
+        require_positive_identifier("session_id", session_id)
+        return self._collection(
+            "ReviewSets_QueryReleaseResults",
+            path_params={"reviewSetId": review_set_id, "sessionId": session_id},
+            filter=filter,
+            order_by=order_by,
+            top=top,
+            skip=skip,
+            count=count,
+        )
+
+    @overload
+    def cancel_release(
+        self: ReviewSetsResource[Literal[False]], review_set_id: int, session_id: int
+    ) -> ReviewSetsCancelReleaseResponse200 | ReviewSetsCancelReleaseResponse202: ...
+
+    @overload
+    def cancel_release(
+        self: ReviewSetsResource[Literal[True]], review_set_id: int, session_id: int
+    ) -> ApiResponseProtocol[
+        ReviewSetsCancelReleaseResponse200 | ReviewSetsCancelReleaseResponse202
+    ]: ...
+
+    def cancel_release(
+        self, review_set_id: int, session_id: int
+    ) -> (
+        ReviewSetsCancelReleaseResponse200
+        | ReviewSetsCancelReleaseResponse202
+        | ApiResponseProtocol[
+            ReviewSetsCancelReleaseResponse200 | ReviewSetsCancelReleaseResponse202
+        ]
+    ):
+        require_positive_identifier("review_set_id", review_set_id)
+        require_positive_identifier("session_id", session_id)
+        response = self._request(
+            "ReviewSets_CancelRelease",
+            path_params={"reviewSetId": review_set_id, "sessionId": session_id},
+        )
+        return self._finish(response, response.data)