step_rest_client 1.0.0__py3-none-any.whl

step_rest_client/api/reporting_api.py

@@ -0,0 +1,707 @@
+# coding: utf-8
+
+"""
+    STEP REST API V2
+
+    <h1>About</h1><p>The STEP REST API V2 provides read and write access to a set of core STEP objects using the HTTP operations GET, PUT, POST, PATCH and DELETE.</p><h1>Resource Representation</h1><p>With the exception of a few resource operations for retrieving and uploading binary data, all request and response bodies are JSON, compliant with the schema documented here.</p><h1>Context and Workspace</h1><p>All requests are handled in a specific STEP context and workspace and both can be specified via query parameters available for all resource operations. A context must always be specified while requests per default will be handled in the &quot;Main&quot; workspace.</p><h1>Polymorphism</h1><p>In STEP, attributes, reference types and data container types can all be either single- or multivalued. The STEP REST API V2 uses polymorphism to address this complexity with resources that include values, references and data containers specified to produce and consume a common &quot;abstract&quot; supertype that always will be one of either the single- or multivalued subtype.<br/>As an example, the GET /entities/{id}/values/{attributeId} resource operation is specified to return a &quot;Value&quot; but as evident from the model, the &quot;Value&quot; will always be &quot;oneOf&quot; either &quot;SingleValue&quot;, that has a &quot;value&quot; property for which the value is an object, or &quot;MultiValue&quot;, that has a &quot;values&quot; property for which the value is an array.<br/>Clients are advised to use the presence or absence of the plural array property (&quot;values&quot;, &quot;references&quot; and &quot;dataContainers&quot;) to determine the concrete type.</p><h1>Authentication</h1><p>The REST API is protected by HTTP Basic Authentication or if OAuth2-based authentication is enabled (SaaS customers only), by Bearer Authentication. With Basic Authentication, user name and password are supplied with each request and it is therefore highly recommended to only use the API in conjunction with HTTPS. For more information about OAuth2-based authentication for SaaS customers, please see the STEP Authentication Guide.</p><h1>Versioning</h1><p>The STEP REST API V2 is versioned using semantic versioning. Stibo Systems reserve the right to make non-breaking, minor / patch changes in any release without warning and clients must be coded / configured to be 'tolerant' and capable of handling such changes.</p><p>Examples of breaking, major changes:</p><ul><li>Renaming of a property</li><li>Removal of a property</li><li>Property type change</li><li>Addition of new property required for write operations</li><li>Marking existing property as required for write operations</li><li>Removal of resource or resource operation</li><li>Materially different behavior for existing resource operation</li></ul><p>Examples of non-breaking, minor / patch changes:</p><ul><li>Addition of new properties in request responses</li><li>Addition of new query parameter not required for write operations</li><li>Addition of new resource or resource operation</li><li>Bug fixes that do not change the schema or resource operations as described here</li><li>Inclusion of a response body for resource operations specified to return a 200 response with no body</li><li>Change of response &quot;Model&quot; / &quot;schema&quot; to type extending the previously specified type</li><li>Renaming a &quot;Model&quot; / &quot;schema&quot; type</li></ul><p>In addition, error message texts may change without warning within the same version. Client program logic should not depend upon the message content.</p><h1>Error Handling</h1><p>The STEP REST API V2 responds with standard HTTP status codes, with 2** responses indicating a success, 4** responses indicating a client error and 5** indicating a server error. Notice that this specification does not specify common error responses like 500 (internal server error) or 401 (unauthorized) for the individual resource operations. Clients should however be capable of handling such responses.</p><p>Error responses have a JSON response body (see Error schema below) containing HTTP status code information in addition to a message providing details about the error. As mentioned above, client program logic should not depend upon the message content.</p><p>The specific status codes used in the API are:</p><ul><li>200 (OK): Success, response may or may not have a body</li><li>201 (Created): Entity successfully created, response may or may not have a body</li><li>400 (Bad request): The server cannot or will not process the request due to an apparent client error</li><li>401 (Unauthorized): Returned only in relation to failed authentication</li><li>404 (Not Found): Returned only in relation to objects specified via path parameters (variable parts of the URL). If STEP objects referenced in request bodies or via query parameters cannot be found, the response will be 400.</li><li>429 (Too Many Requests): Clients are per default limited to 100 requests per second. Returned if the rate limit is exceeded.</li><li>500 (Internal Server Error): Unexpected error (could potentially cover an issue that rightfully should be a 400)</li></ul>
+
+    The version of the OpenAPI document: 1.3.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from step_rest_client.models.background_process_identification import BackgroundProcessIdentification
+
+from step_rest_client.api_client import ApiClient, RequestSerialized
+from step_rest_client.api_response import ApiResponse
+from step_rest_client.rest import RESTResponseType
+
+
+class ReportingApi:
+    """NOTE: This class is auto generated by OpenAPI Generator
+    Ref: https://openapi-generator.tech
+
+    Do not edit the class manually.
+    """
+
+    def __init__(self, api_client=None) -> None:
+        if api_client is None:
+            api_client = ApiClient.get_default()
+        self.api_client = api_client
+
+
+    @validate_call
+    def reports_historic_changes_report_id_clean_up_post(
+        self,
+        report_id: Annotated[StrictStr, Field(description="ID of the report for which to delete the confguration")],
+        context: Annotated[StrictStr, Field(description="ID of the context in which to perform the operation")],
+        workspace: Annotated[Optional[StrictStr], Field(description="ID of the workspace in which to perform the operation. Defaults to \"Main\".")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> None:
+        """Deletes configuration objects specific to a report.
+
+        When a report is started, multiple configuration objects are created (event processors and setup groups). This operation can be called for completed reports and will delete said configuration objects. Once this endpoint has been called, it is no longer possible to retrieve the generated report.
+
+        :param report_id: ID of the report for which to delete the confguration (required)
+        :type report_id: str
+        :param context: ID of the context in which to perform the operation (required)
+        :type context: str
+        :param workspace: ID of the workspace in which to perform the operation. Defaults to \"Main\".
+        :type workspace: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._reports_historic_changes_report_id_clean_up_post_serialize(
+            report_id=report_id,
+            context=context,
+            workspace=workspace,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': None,
+            '400': "Error",
+            '404': "Error",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def reports_historic_changes_report_id_clean_up_post_with_http_info(
+        self,
+        report_id: Annotated[StrictStr, Field(description="ID of the report for which to delete the confguration")],
+        context: Annotated[StrictStr, Field(description="ID of the context in which to perform the operation")],
+        workspace: Annotated[Optional[StrictStr], Field(description="ID of the workspace in which to perform the operation. Defaults to \"Main\".")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[None]:
+        """Deletes configuration objects specific to a report.
+
+        When a report is started, multiple configuration objects are created (event processors and setup groups). This operation can be called for completed reports and will delete said configuration objects. Once this endpoint has been called, it is no longer possible to retrieve the generated report.
+
+        :param report_id: ID of the report for which to delete the confguration (required)
+        :type report_id: str
+        :param context: ID of the context in which to perform the operation (required)
+        :type context: str
+        :param workspace: ID of the workspace in which to perform the operation. Defaults to \"Main\".
+        :type workspace: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._reports_historic_changes_report_id_clean_up_post_serialize(
+            report_id=report_id,
+            context=context,
+            workspace=workspace,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': None,
+            '400': "Error",
+            '404': "Error",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def reports_historic_changes_report_id_clean_up_post_without_preload_content(
+        self,
+        report_id: Annotated[StrictStr, Field(description="ID of the report for which to delete the confguration")],
+        context: Annotated[StrictStr, Field(description="ID of the context in which to perform the operation")],
+        workspace: Annotated[Optional[StrictStr], Field(description="ID of the workspace in which to perform the operation. Defaults to \"Main\".")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Deletes configuration objects specific to a report.
+
+        When a report is started, multiple configuration objects are created (event processors and setup groups). This operation can be called for completed reports and will delete said configuration objects. Once this endpoint has been called, it is no longer possible to retrieve the generated report.
+
+        :param report_id: ID of the report for which to delete the confguration (required)
+        :type report_id: str
+        :param context: ID of the context in which to perform the operation (required)
+        :type context: str
+        :param workspace: ID of the workspace in which to perform the operation. Defaults to \"Main\".
+        :type workspace: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._reports_historic_changes_report_id_clean_up_post_serialize(
+            report_id=report_id,
+            context=context,
+            workspace=workspace,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': None,
+            '400': "Error",
+            '404': "Error",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _reports_historic_changes_report_id_clean_up_post_serialize(
+        self,
+        report_id,
+        context,
+        workspace,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if report_id is not None:
+            _path_params['reportID'] = report_id
+        # process the query parameters
+        if context is not None:
+            
+            _query_params.append(('context', context))
+            
+        if workspace is not None:
+            
+            _query_params.append(('workspace', workspace))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'basicAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/reports/historic-changes/{reportID}/clean-up',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def reports_historic_changes_report_id_post(
+        self,
+        report_id: Annotated[StrictStr, Field(description="ID of the report")],
+        analyzer_id: Annotated[StrictStr, Field(description="ID of the business function to be used for analyzing revisions modified by the specified users within the specified timeframe. The function must take a Revision as input and output a String.")],
+        beginning: Annotated[StrictStr, Field(description="The least (first) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\".")],
+        end: Annotated[StrictStr, Field(description="The greatest (last) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\".")],
+        context: Annotated[StrictStr, Field(description="ID of the context in which to perform the operation")],
+        user_ids: Annotated[Optional[List[StrictStr]], Field(description="IDs of users whose changes should be considered. If null or empty, all users are eligible for critical scrutiny.")] = None,
+        workspace: Annotated[Optional[StrictStr], Field(description="ID of the workspace in which to perform the operation. Defaults to \"Main\".")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> BackgroundProcessIdentification:
+        """Starts historic changes report generation
+
+        Starts a reporting process that collects revisions modified by the specified user(s) within the specified timespan and feeds them one at a time to the specified business function. The output from the business function is written to a report available as an attachment to the background process identified in the response. If the business function output is null, the revision will not figure in the final report. Do not expect miracles as for processing time. Most of the data to be handled must be fetched detail by detail from the database server. The analysis is quickly restricted by the timing- and user-bounds described below. The rest is up to the analyzing business function.
+
+        :param report_id: ID of the report (required)
+        :type report_id: str
+        :param analyzer_id: ID of the business function to be used for analyzing revisions modified by the specified users within the specified timeframe. The function must take a Revision as input and output a String. (required)
+        :type analyzer_id: str
+        :param beginning: The least (first) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\". (required)
+        :type beginning: str
+        :param end: The greatest (last) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\". (required)
+        :type end: str
+        :param context: ID of the context in which to perform the operation (required)
+        :type context: str
+        :param user_ids: IDs of users whose changes should be considered. If null or empty, all users are eligible for critical scrutiny.
+        :type user_ids: List[str]
+        :param workspace: ID of the workspace in which to perform the operation. Defaults to \"Main\".
+        :type workspace: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._reports_historic_changes_report_id_post_serialize(
+            report_id=report_id,
+            analyzer_id=analyzer_id,
+            beginning=beginning,
+            end=end,
+            context=context,
+            user_ids=user_ids,
+            workspace=workspace,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "BackgroundProcessIdentification",
+            '400': "Error",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def reports_historic_changes_report_id_post_with_http_info(
+        self,
+        report_id: Annotated[StrictStr, Field(description="ID of the report")],
+        analyzer_id: Annotated[StrictStr, Field(description="ID of the business function to be used for analyzing revisions modified by the specified users within the specified timeframe. The function must take a Revision as input and output a String.")],
+        beginning: Annotated[StrictStr, Field(description="The least (first) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\".")],
+        end: Annotated[StrictStr, Field(description="The greatest (last) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\".")],
+        context: Annotated[StrictStr, Field(description="ID of the context in which to perform the operation")],
+        user_ids: Annotated[Optional[List[StrictStr]], Field(description="IDs of users whose changes should be considered. If null or empty, all users are eligible for critical scrutiny.")] = None,
+        workspace: Annotated[Optional[StrictStr], Field(description="ID of the workspace in which to perform the operation. Defaults to \"Main\".")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[BackgroundProcessIdentification]:
+        """Starts historic changes report generation
+
+        Starts a reporting process that collects revisions modified by the specified user(s) within the specified timespan and feeds them one at a time to the specified business function. The output from the business function is written to a report available as an attachment to the background process identified in the response. If the business function output is null, the revision will not figure in the final report. Do not expect miracles as for processing time. Most of the data to be handled must be fetched detail by detail from the database server. The analysis is quickly restricted by the timing- and user-bounds described below. The rest is up to the analyzing business function.
+
+        :param report_id: ID of the report (required)
+        :type report_id: str
+        :param analyzer_id: ID of the business function to be used for analyzing revisions modified by the specified users within the specified timeframe. The function must take a Revision as input and output a String. (required)
+        :type analyzer_id: str
+        :param beginning: The least (first) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\". (required)
+        :type beginning: str
+        :param end: The greatest (last) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\". (required)
+        :type end: str
+        :param context: ID of the context in which to perform the operation (required)
+        :type context: str
+        :param user_ids: IDs of users whose changes should be considered. If null or empty, all users are eligible for critical scrutiny.
+        :type user_ids: List[str]
+        :param workspace: ID of the workspace in which to perform the operation. Defaults to \"Main\".
+        :type workspace: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._reports_historic_changes_report_id_post_serialize(
+            report_id=report_id,
+            analyzer_id=analyzer_id,
+            beginning=beginning,
+            end=end,
+            context=context,
+            user_ids=user_ids,
+            workspace=workspace,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "BackgroundProcessIdentification",
+            '400': "Error",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def reports_historic_changes_report_id_post_without_preload_content(
+        self,
+        report_id: Annotated[StrictStr, Field(description="ID of the report")],
+        analyzer_id: Annotated[StrictStr, Field(description="ID of the business function to be used for analyzing revisions modified by the specified users within the specified timeframe. The function must take a Revision as input and output a String.")],
+        beginning: Annotated[StrictStr, Field(description="The least (first) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\".")],
+        end: Annotated[StrictStr, Field(description="The greatest (last) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\".")],
+        context: Annotated[StrictStr, Field(description="ID of the context in which to perform the operation")],
+        user_ids: Annotated[Optional[List[StrictStr]], Field(description="IDs of users whose changes should be considered. If null or empty, all users are eligible for critical scrutiny.")] = None,
+        workspace: Annotated[Optional[StrictStr], Field(description="ID of the workspace in which to perform the operation. Defaults to \"Main\".")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Starts historic changes report generation
+
+        Starts a reporting process that collects revisions modified by the specified user(s) within the specified timespan and feeds them one at a time to the specified business function. The output from the business function is written to a report available as an attachment to the background process identified in the response. If the business function output is null, the revision will not figure in the final report. Do not expect miracles as for processing time. Most of the data to be handled must be fetched detail by detail from the database server. The analysis is quickly restricted by the timing- and user-bounds described below. The rest is up to the analyzing business function.
+
+        :param report_id: ID of the report (required)
+        :type report_id: str
+        :param analyzer_id: ID of the business function to be used for analyzing revisions modified by the specified users within the specified timeframe. The function must take a Revision as input and output a String. (required)
+        :type analyzer_id: str
+        :param beginning: The least (first) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\". (required)
+        :type beginning: str
+        :param end: The greatest (last) boundary restricting the timespan to consider. Must be supplied in the ISO8601 format. E.g. \"1794-01-03 11:28:47\". (required)
+        :type end: str
+        :param context: ID of the context in which to perform the operation (required)
+        :type context: str
+        :param user_ids: IDs of users whose changes should be considered. If null or empty, all users are eligible for critical scrutiny.
+        :type user_ids: List[str]
+        :param workspace: ID of the workspace in which to perform the operation. Defaults to \"Main\".
+        :type workspace: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._reports_historic_changes_report_id_post_serialize(
+            report_id=report_id,
+            analyzer_id=analyzer_id,
+            beginning=beginning,
+            end=end,
+            context=context,
+            user_ids=user_ids,
+            workspace=workspace,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "BackgroundProcessIdentification",
+            '400': "Error",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _reports_historic_changes_report_id_post_serialize(
+        self,
+        report_id,
+        analyzer_id,
+        beginning,
+        end,
+        context,
+        user_ids,
+        workspace,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+            'userIDs': 'multi',
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if report_id is not None:
+            _path_params['reportID'] = report_id
+        # process the query parameters
+        if analyzer_id is not None:
+            
+            _query_params.append(('analyzerID', analyzer_id))
+            
+        if beginning is not None:
+            
+            _query_params.append(('beginning', beginning))
+            
+        if end is not None:
+            
+            _query_params.append(('end', end))
+            
+        if user_ids is not None:
+            
+            _query_params.append(('userIDs', user_ids))
+            
+        if context is not None:
+            
+            _query_params.append(('context', context))
+            
+        if workspace is not None:
+            
+            _query_params.append(('workspace', workspace))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'basicAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/reports/historic-changes/{reportID}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+