grexx-api 1.0.0

package/src/generated/services/CaseService.ts

@@ -0,0 +1,800 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AbstractReference } from '../models/AbstractReference';
+import type { Activity } from '../models/Activity';
+import type { AdditionalAggregateColumn } from '../models/AdditionalAggregateColumn';
+import type { AdditionalDataHistoryColumn } from '../models/AdditionalDataHistoryColumn';
+import type { AdditionalDerivedColumn } from '../models/AdditionalDerivedColumn';
+import type { AdditionalExternalColumn } from '../models/AdditionalExternalColumn';
+import type { AdditionalGroupbyColumn } from '../models/AdditionalGroupbyColumn';
+import type { AdditionalMetaColumn } from '../models/AdditionalMetaColumn';
+import type { AdditionalTemplateColumn } from '../models/AdditionalTemplateColumn';
+import type { CaseReference } from '../models/CaseReference';
+import type { CasetypeCss } from '../models/CasetypeCss';
+import type { ColumnId } from '../models/ColumnId';
+import type { ColumnIdentifier } from '../models/ColumnIdentifier';
+import type { DatasetResult } from '../models/DatasetResult';
+import type { FormFieldConditionList } from '../models/FormFieldConditionList';
+import type { FormFieldNotCondition } from '../models/FormFieldNotCondition';
+import type { FormFieldSimpleCondition } from '../models/FormFieldSimpleCondition';
+import type { MapStringObject } from '../models/MapStringObject';
+import type { SortConfigSearchCondition } from '../models/SortConfigSearchCondition';
+import type { SortConfigSearchList } from '../models/SortConfigSearchList';
+import type { SortConfigSort } from '../models/SortConfigSort';
+import type { UnversionedReference } from '../models/UnversionedReference';
+import type { VersionedReference } from '../models/VersionedReference';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class CaseService {
+    /**
+     * Retrieve information on a case
+     * @param casePath Path or Id of case
+     * @param css Set css
+     * @param rootline Set rootline
+     * @param views Set views
+     * @returns any Retrieve information on a case
+     * @throws ApiError
+     */
+    public static caseInfo(
+        casePath: string,
+        css?: boolean,
+        rootline?: boolean,
+        views?: boolean,
+    ): CancelablePromise<{
+        caseRedirect?: string;
+        casetype: {
+            cssTemplates?: Array<CasetypeCss>;
+            defaultView?: VersionedReference;
+            /**
+             * the name of the casetype
+             */
+            name: string;
+            platformCssTemplates?: Array<CasetypeCss>;
+            platformTheme?: any;
+            views?: Array<any>;
+        };
+        devParentCase?: UnversionedReference;
+        id: CaseReference;
+        jumpToCase?: boolean;
+        jumpToCase_case?: UnversionedReference;
+        jumpToCase_view?: AbstractReference;
+        redirectToURL?: string;
+        redirectToURL_data?: string;
+        redirectToURL_encoding?: string;
+        redirectToURL_method?: string;
+        reference?: string;
+        reloadCaches?: string;
+        rootline?: Array<{
+            id: CaseReference;
+            reference?: string;
+        }>;
+        submitMessageBody?: string;
+        submitMessageButtonText?: string;
+        submitMessageStyle?: string;
+        userCaseLocale?: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/case-info/{casePath}',
+            path: {
+                'casePath': casePath,
+            },
+            query: {
+                'css': css,
+                'rootline': rootline,
+                'views': views,
+            },
+        });
+    }
+    /**
+     * Retrieve the contents of a dataset, rights are checked via dataset rights
+     * @param casePath Path or Id of case
+     * @param dataset ID of dataset
+     * @param format Format of the result
+     * @param requestBody
+     * @returns DatasetResult Retrieve the contents of a dataset, rights are checked via dataset rights
+     * @throws ApiError
+     */
+    public static datasetRetrieve(
+        casePath: string,
+        dataset: UnversionedReference,
+        format: 'simple' | 'full' = 'simple',
+        requestBody?: {
+            additionalColumns?: Array<(AdditionalTemplateColumn | AdditionalMetaColumn | AdditionalAggregateColumn | AdditionalGroupbyColumn | AdditionalDataHistoryColumn | AdditionalExternalColumn | AdditionalDerivedColumn)>;
+            allowHtmlAlways?: boolean;
+            calculateFullCount?: boolean;
+            columns?: Array<ColumnId>;
+            dataset: AbstractReference;
+            doAnalysis?: boolean;
+            forceCount?: boolean;
+            identifier?: ColumnIdentifier;
+            limit?: number;
+            search?: (SortConfigSearchList | SortConfigSearchCondition);
+            skip?: number;
+            sort?: Array<SortConfigSort>;
+            unAggregatedAdditionalColumns?: Array<(AdditionalTemplateColumn | AdditionalMetaColumn | AdditionalAggregateColumn | AdditionalGroupbyColumn | AdditionalDataHistoryColumn | AdditionalExternalColumn | AdditionalDerivedColumn)>;
+            unAggregatedSearch?: (SortConfigSearchList | SortConfigSearchCondition);
+        },
+    ): CancelablePromise<DatasetResult> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/dataset/{dataset}/{casePath}',
+            path: {
+                'casePath': casePath,
+                'dataset': dataset,
+            },
+            query: {
+                'format': format,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Retrieve the contents of a form, rights are checked via form rights
+     * @param casePath Path or Id of case
+     * @param formId ID of form
+     * @param form Set form
+     * @param format Format of the result
+     * @returns any Retrieve the contents of a form, rights are checked via form rights
+     * @throws ApiError
+     */
+    public static formRetrieve(
+        casePath: string,
+        formId: UnversionedReference,
+        form?: any,
+        format: 'simple' | 'extended' | 'full' = 'simple',
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/form/{form}/{casePath}',
+            path: {
+                'casePath': casePath,
+                'formId': formId,
+            },
+            query: {
+                'form': form,
+                'format': format,
+            },
+        });
+    }
+    /**
+     * Retrieve the contents of a dataset, rights are checked via widget rights
+     * @param casePath Path or Id of case
+     * @param dataset ID of dataset
+     * @param widget ID of widget
+     * @param format Format of the result
+     * @param requestBody
+     * @returns DatasetResult Retrieve the contents of a dataset, rights are checked via widget rights
+     * @throws ApiError
+     */
+    public static datasetRetrieveViaWidget(
+        casePath: string,
+        dataset: UnversionedReference,
+        widget: UnversionedReference,
+        format: 'simple' | 'full' = 'full',
+        requestBody?: {
+            additionalColumns?: Array<(AdditionalTemplateColumn | AdditionalMetaColumn | AdditionalAggregateColumn | AdditionalGroupbyColumn | AdditionalDataHistoryColumn | AdditionalExternalColumn | AdditionalDerivedColumn)>;
+            allowHtmlAlways?: boolean;
+            calculateFullCount?: boolean;
+            columns?: Array<ColumnId>;
+            dataset: AbstractReference;
+            doAnalysis?: boolean;
+            forceCount?: boolean;
+            identifier?: ColumnIdentifier;
+            limit?: number;
+            search?: (SortConfigSearchList | SortConfigSearchCondition);
+            skip?: number;
+            sort?: Array<SortConfigSort>;
+            unAggregatedAdditionalColumns?: Array<(AdditionalTemplateColumn | AdditionalMetaColumn | AdditionalAggregateColumn | AdditionalGroupbyColumn | AdditionalDataHistoryColumn | AdditionalExternalColumn | AdditionalDerivedColumn)>;
+            unAggregatedSearch?: (SortConfigSearchList | SortConfigSearchCondition);
+            widget: AbstractReference;
+            widgetCaseid?: CaseReference;
+        },
+    ): CancelablePromise<DatasetResult> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/widget-dataset/{dataset}/{widget}/{casePath}',
+            path: {
+                'casePath': casePath,
+                'dataset': dataset,
+                'widget': widget,
+            },
+            query: {
+                'format': format,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Submit (create and submit) an activity based on the activity ID and filled in fields
+     * @param casePath Path or Id of case
+     * @param activity ID of activity
+     * @param requestBody
+     * @returns any Submit (create and submit) an activity based on the activity ID and filled in fields
+     * @throws ApiError
+     */
+    public static activityDirectSubmit(
+        casePath: string,
+        activity: UnversionedReference,
+        requestBody?: Record<string, any>,
+    ): CancelablePromise<{
+        createdCase?: CaseReference;
+        jumpToCase?: boolean;
+        jumpToCase_case?: UnversionedReference;
+        jumpToCase_view?: AbstractReference;
+        redirectToURL?: string;
+        redirectToURL_data?: string;
+        redirectToURL_encoding?: string;
+        redirectToURL_method?: string;
+        reloadCaches?: string;
+        returnResult?: MapStringObject;
+        status?: string;
+        submitMessageBody?: string;
+        submitMessageButtonText?: string;
+        submitMessageStyle?: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/activity/{activity}/{casePath}',
+            path: {
+                'casePath': casePath,
+                'activity': activity,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Create a new optional task based on an activity ID
+     * @param casePath Path or Id of case
+     * @param activity ID of activity
+     * @param format Format of the result
+     * @param requestBody
+     * @returns any Create a new optional task based on an activity ID
+     * @throws ApiError
+     */
+    public static taskCreate(
+        casePath: string,
+        activity: UnversionedReference,
+        format: 'simple' | 'full' = 'full',
+        requestBody?: ({
+            activity: AbstractReference;
+            autoProgress?: boolean;
+            skipCheckRights?: boolean;
+            type: 'optional';
+        } | {
+            activityTag: string;
+            autoProgress?: boolean;
+            skipCheckRights?: boolean;
+            type: 'optionalByTag';
+        } | {
+            autoProgress?: boolean;
+            skipCheckRights?: boolean;
+            task?: number;
+            type: 'mandatory' | 'required';
+        }),
+    ): CancelablePromise<{
+        activity?: Activity;
+        form?: any;
+        formCondition?: (FormFieldConditionList | FormFieldSimpleCondition | FormFieldNotCondition);
+        name?: string;
+        parentCase?: UnversionedReference;
+        startActivity?: Activity;
+        task?: number;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/task-create/{activity}/{casePath}',
+            path: {
+                'casePath': casePath,
+                'activity': activity,
+            },
+            query: {
+                'format': format,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Retrieve an existing task based on the task ID
+     * @param casePath Path or Id of case
+     * @param task ID of task
+     * @param format Format of the result
+     * @returns any Retrieve an existing task based on the task ID
+     * @throws ApiError
+     */
+    public static taskInfo(
+        casePath: string,
+        task: number,
+        format: 'simple' | 'full' = 'full',
+    ): CancelablePromise<{
+        activity?: Activity;
+        form?: any;
+        formCondition?: (FormFieldConditionList | FormFieldSimpleCondition | FormFieldNotCondition);
+        name?: string;
+        parentCase?: UnversionedReference;
+        startActivity?: Activity;
+        task?: number;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/task-info/{task}/{casePath}',
+            path: {
+                'casePath': casePath,
+                'task': task,
+            },
+            query: {
+                'format': format,
+            },
+        });
+    }
+    /**
+     * Submit an existing task based on the task ID and filled in fields
+     * @param casePath Path or Id of case
+     * @param task ID of task
+     * @param requestBody
+     * @returns any Submit an existing task based on the task ID and filled in fields
+     * @throws ApiError
+     */
+    public static taskSubmit(
+        casePath: string,
+        task: number,
+        requestBody?: ({
+            activity: AbstractReference;
+            autoProgress?: boolean;
+            fields?: MapStringObject;
+            returnResult?: boolean;
+            skipCheckRights?: boolean;
+            type?: 'optional';
+        } | {
+            autoProgress?: boolean;
+            fields?: Array<{
+                /**
+                 * Only allowed in the studio's.
+                 */
+                devref?: string;
+                /**
+                 * The external reference.
+                 */
+                externalReference?: string;
+                id?: AbstractReference;
+                /**
+                 * Not used in the backend side
+                 */
+                name?: string;
+                value?: any;
+            }>;
+            returnResult?: boolean;
+            skipCheckRights?: boolean;
+            task?: number;
+            type?: 'task-array';
+        } | {
+            autoProgress?: boolean;
+            fields?: MapStringObject;
+            returnResult?: boolean;
+            skipCheckRights?: boolean;
+            task?: number;
+            type?: 'task-json';
+        }),
+    ): CancelablePromise<{
+        createdCase?: CaseReference;
+        jumpToCase?: boolean;
+        jumpToCase_case?: UnversionedReference;
+        jumpToCase_view?: AbstractReference;
+        redirectToURL?: string;
+        redirectToURL_data?: string;
+        redirectToURL_encoding?: string;
+        redirectToURL_method?: string;
+        reloadCaches?: string;
+        returnResult?: MapStringObject;
+        status?: string;
+        submitMessageBody?: string;
+        submitMessageButtonText?: string;
+        submitMessageStyle?: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/task-submit/{task}/{casePath}',
+            path: {
+                'casePath': casePath,
+                'task': task,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @deprecated
+     * Retrieve information on a case
+     * @param caseId ID of case
+     * @param css Set css
+     * @param rootline Set rootline
+     * @param views Set views
+     * @returns any Retrieve information on a case
+     * @throws ApiError
+     */
+    public static caseView(
+        caseId: UnversionedReference,
+        css?: boolean,
+        rootline?: boolean,
+        views?: boolean,
+    ): CancelablePromise<{
+        caseRedirect?: string;
+        casetype: {
+            cssTemplates?: Array<CasetypeCss>;
+            defaultView?: VersionedReference;
+            /**
+             * the name of the casetype
+             */
+            name: string;
+            platformCssTemplates?: Array<CasetypeCss>;
+            platformTheme?: any;
+            views?: Array<any>;
+        };
+        devParentCase?: UnversionedReference;
+        id: CaseReference;
+        jumpToCase?: boolean;
+        jumpToCase_case?: UnversionedReference;
+        jumpToCase_view?: AbstractReference;
+        redirectToURL?: string;
+        redirectToURL_data?: string;
+        redirectToURL_encoding?: string;
+        redirectToURL_method?: string;
+        reference?: string;
+        reloadCaches?: string;
+        rootline?: Array<{
+            id: CaseReference;
+            reference?: string;
+        }>;
+        submitMessageBody?: string;
+        submitMessageButtonText?: string;
+        submitMessageStyle?: string;
+        userCaseLocale?: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/case/{caseId}',
+            path: {
+                'caseId': caseId,
+            },
+            query: {
+                'css': css,
+                'rootline': rootline,
+                'views': views,
+            },
+        });
+    }
+    /**
+     * @deprecated
+     * Retrieve the contents of a dataset, rights are checked via dataset rights
+     * @param caseId ID of case
+     * @param dataset ID of dataset
+     * @param format Format of the result
+     * @param requestBody
+     * @returns DatasetResult Retrieve the contents of a dataset, rights are checked via dataset rights
+     * @throws ApiError
+     */
+    public static datasetGet(
+        caseId: UnversionedReference,
+        dataset: UnversionedReference,
+        format: 'simple' | 'full' = 'simple',
+        requestBody?: {
+            additionalColumns?: Array<(AdditionalTemplateColumn | AdditionalMetaColumn | AdditionalAggregateColumn | AdditionalGroupbyColumn | AdditionalDataHistoryColumn | AdditionalExternalColumn | AdditionalDerivedColumn)>;
+            allowHtmlAlways?: boolean;
+            calculateFullCount?: boolean;
+            columns?: Array<ColumnId>;
+            dataset: AbstractReference;
+            doAnalysis?: boolean;
+            forceCount?: boolean;
+            identifier?: ColumnIdentifier;
+            limit?: number;
+            search?: (SortConfigSearchList | SortConfigSearchCondition);
+            skip?: number;
+            sort?: Array<SortConfigSort>;
+            unAggregatedAdditionalColumns?: Array<(AdditionalTemplateColumn | AdditionalMetaColumn | AdditionalAggregateColumn | AdditionalGroupbyColumn | AdditionalDataHistoryColumn | AdditionalExternalColumn | AdditionalDerivedColumn)>;
+            unAggregatedSearch?: (SortConfigSearchList | SortConfigSearchCondition);
+        },
+    ): CancelablePromise<DatasetResult> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/case/{caseId}/dataset/{dataset}',
+            path: {
+                'caseId': caseId,
+                'dataset': dataset,
+            },
+            query: {
+                'format': format,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @deprecated
+     * Retrieve the contents of a form, rights are checked via form rights
+     * @param caseId ID of case
+     * @param formId ID of form
+     * @param form Set form
+     * @param format Format of the result
+     * @returns any Retrieve the contents of a form, rights are checked via form rights
+     * @throws ApiError
+     */
+    public static formGet(
+        caseId: UnversionedReference,
+        formId: UnversionedReference,
+        form?: any,
+        format: 'simple' | 'extended' | 'full' = 'simple',
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/case/{caseId}/form/{form}',
+            path: {
+                'caseId': caseId,
+                'formId': formId,
+            },
+            query: {
+                'form': form,
+                'format': format,
+            },
+        });
+    }
+    /**
+     * @deprecated
+     * Retrieve the contents of a dataset, rights are checked via widget rights
+     * @param caseId ID of case
+     * @param dataset ID of dataset
+     * @param widget ID of widget
+     * @param format Format of the result
+     * @param requestBody
+     * @returns DatasetResult Retrieve the contents of a dataset, rights are checked via widget rights
+     * @throws ApiError
+     */
+    public static datasetGetViaWidget(
+        caseId: UnversionedReference,
+        dataset: UnversionedReference,
+        widget: UnversionedReference,
+        format: 'simple' | 'full' = 'full',
+        requestBody?: {
+            additionalColumns?: Array<(AdditionalTemplateColumn | AdditionalMetaColumn | AdditionalAggregateColumn | AdditionalGroupbyColumn | AdditionalDataHistoryColumn | AdditionalExternalColumn | AdditionalDerivedColumn)>;
+            allowHtmlAlways?: boolean;
+            calculateFullCount?: boolean;
+            columns?: Array<ColumnId>;
+            dataset: AbstractReference;
+            doAnalysis?: boolean;
+            forceCount?: boolean;
+            identifier?: ColumnIdentifier;
+            limit?: number;
+            search?: (SortConfigSearchList | SortConfigSearchCondition);
+            skip?: number;
+            sort?: Array<SortConfigSort>;
+            unAggregatedAdditionalColumns?: Array<(AdditionalTemplateColumn | AdditionalMetaColumn | AdditionalAggregateColumn | AdditionalGroupbyColumn | AdditionalDataHistoryColumn | AdditionalExternalColumn | AdditionalDerivedColumn)>;
+            unAggregatedSearch?: (SortConfigSearchList | SortConfigSearchCondition);
+            widget: AbstractReference;
+            widgetCaseid?: CaseReference;
+        },
+    ): CancelablePromise<DatasetResult> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/case/{caseId}/dataset/{dataset}/widget/{widget}',
+            path: {
+                'caseId': caseId,
+                'dataset': dataset,
+                'widget': widget,
+            },
+            query: {
+                'format': format,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @deprecated
+     * Submit (create and submit) an activity based on the activity ID and filled in fields
+     * @param caseId ID of case
+     * @param activity ID of activity
+     * @param requestBody
+     * @returns any Submit (create and submit) an activity based on the activity ID and filled in fields
+     * @throws ApiError
+     */
+    public static activitySubmit(
+        caseId: UnversionedReference,
+        activity: UnversionedReference,
+        requestBody?: Record<string, any>,
+    ): CancelablePromise<{
+        createdCase?: CaseReference;
+        jumpToCase?: boolean;
+        jumpToCase_case?: UnversionedReference;
+        jumpToCase_view?: AbstractReference;
+        redirectToURL?: string;
+        redirectToURL_data?: string;
+        redirectToURL_encoding?: string;
+        redirectToURL_method?: string;
+        reloadCaches?: string;
+        returnResult?: MapStringObject;
+        status?: string;
+        submitMessageBody?: string;
+        submitMessageButtonText?: string;
+        submitMessageStyle?: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/case/{caseId}/activity/{activity}',
+            path: {
+                'caseId': caseId,
+                'activity': activity,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @deprecated
+     * Create a new optional task based on an activity ID
+     * @param caseId ID of case
+     * @param activity ID of activity
+     * @param format Format of the result
+     * @param requestBody
+     * @returns any Create a new optional task based on an activity ID
+     * @throws ApiError
+     */
+    public static caseTaskCreate(
+        caseId: UnversionedReference,
+        activity: UnversionedReference,
+        format: 'simple' | 'full' = 'full',
+        requestBody?: ({
+            activity: AbstractReference;
+            autoProgress?: boolean;
+            skipCheckRights?: boolean;
+            type: 'optional';
+        } | {
+            activityTag: string;
+            autoProgress?: boolean;
+            skipCheckRights?: boolean;
+            type: 'optionalByTag';
+        } | {
+            autoProgress?: boolean;
+            skipCheckRights?: boolean;
+            task?: number;
+            type: 'mandatory' | 'required';
+        }),
+    ): CancelablePromise<{
+        activity?: Activity;
+        form?: any;
+        formCondition?: (FormFieldConditionList | FormFieldSimpleCondition | FormFieldNotCondition);
+        name?: string;
+        parentCase?: UnversionedReference;
+        startActivity?: Activity;
+        task?: number;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/case/{caseId}/task/create/{activity}',
+            path: {
+                'caseId': caseId,
+                'activity': activity,
+            },
+            query: {
+                'format': format,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @deprecated
+     * Retrieve an existing task based on the task ID
+     * @param caseId ID of case
+     * @param task ID of task
+     * @param format Format of the result
+     * @returns any Retrieve an existing task based on the task ID
+     * @throws ApiError
+     */
+    public static caseTaskGet(
+        caseId: UnversionedReference,
+        task: number,
+        format: 'simple' | 'full' = 'full',
+    ): CancelablePromise<{
+        activity?: Activity;
+        form?: any;
+        formCondition?: (FormFieldConditionList | FormFieldSimpleCondition | FormFieldNotCondition);
+        name?: string;
+        parentCase?: UnversionedReference;
+        startActivity?: Activity;
+        task?: number;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/case/{caseId}/task/{task}',
+            path: {
+                'caseId': caseId,
+                'task': task,
+            },
+            query: {
+                'format': format,
+            },
+        });
+    }
+    /**
+     * @deprecated
+     * Submit an existing task based on the task ID and filled in fields
+     * @param caseId ID of case
+     * @param task ID of task
+     * @param requestBody
+     * @returns any Submit an existing task based on the task ID and filled in fields
+     * @throws ApiError
+     */
+    public static caseTaskSubmit(
+        caseId: UnversionedReference,
+        task: number,
+        requestBody?: ({
+            activity: AbstractReference;
+            autoProgress?: boolean;
+            fields?: MapStringObject;
+            returnResult?: boolean;
+            skipCheckRights?: boolean;
+            type?: 'optional';
+        } | {
+            autoProgress?: boolean;
+            fields?: Array<{
+                /**
+                 * Only allowed in the studio's.
+                 */
+                devref?: string;
+                /**
+                 * The external reference.
+                 */
+                externalReference?: string;
+                id?: AbstractReference;
+                /**
+                 * Not used in the backend side
+                 */
+                name?: string;
+                value?: any;
+            }>;
+            returnResult?: boolean;
+            skipCheckRights?: boolean;
+            task?: number;
+            type?: 'task-array';
+        } | {
+            autoProgress?: boolean;
+            fields?: MapStringObject;
+            returnResult?: boolean;
+            skipCheckRights?: boolean;
+            task?: number;
+            type?: 'task-json';
+        }),
+    ): CancelablePromise<{
+        createdCase?: CaseReference;
+        jumpToCase?: boolean;
+        jumpToCase_case?: UnversionedReference;
+        jumpToCase_view?: AbstractReference;
+        redirectToURL?: string;
+        redirectToURL_data?: string;
+        redirectToURL_encoding?: string;
+        redirectToURL_method?: string;
+        reloadCaches?: string;
+        returnResult?: MapStringObject;
+        status?: string;
+        submitMessageBody?: string;
+        submitMessageButtonText?: string;
+        submitMessageStyle?: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/case/{caseId}/task/{task}',
+            path: {
+                'caseId': caseId,
+                'task': task,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}