tianji-client-sdk/src/open/client/services.gen.ts

// This file is auto-generated by @hey-api/openapi-ts

import type { CancelablePromise } from './core/CancelablePromise';
import { OpenAPI } from './core/OpenAPI';
import { request as __request } from './core/request';
import type { $OpenApiTs } from './types.gen';

export class AiService {
    /**
     * classify survey
     * @param data The data for the request.
     * @param data.requestBody
     * @returns string Successful response
     * @throws ApiError
     */
    public static aiClassifySurvey(data: $OpenApiTs['/ai/classifySurvey']['post']['req']): CancelablePromise<$OpenApiTs['/ai/classifySurvey']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/ai/classifySurvey',
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * translate survey
     * @param data The data for the request.
     * @param data.requestBody
     * @returns string Successful response
     * @throws ApiError
     */
    public static aiTranslateSurvey(data: $OpenApiTs['/ai/translateSurvey']['post']['req']): CancelablePromise<$OpenApiTs['/ai/translateSurvey']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/ai/translateSurvey',
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.gatewayId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static aiGatewayInfo(data: $OpenApiTs['/aiGateway/info']['get']['req']): CancelablePromise<$OpenApiTs['/aiGateway/info']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/aiGateway/info',
            query: {
                workspaceId: data.workspaceId,
                gatewayId: data.gatewayId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static aiGatewayUpdate(data: $OpenApiTs['/aiGateway/update']['patch']['req']): CancelablePromise<$OpenApiTs['/aiGateway/update']['patch']['res'][200]> {
        return __request(OpenAPI, {
            method: 'PATCH',
            url: '/aiGateway/update',
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.gatewayId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static aiGatewayDelete(data: $OpenApiTs['/aiGateway/delete']['delete']['req']): CancelablePromise<$OpenApiTs['/aiGateway/delete']['delete']['res'][200]> {
        return __request(OpenAPI, {
            method: 'DELETE',
            url: '/aiGateway/delete',
            query: {
                workspaceId: data.workspaceId,
                gatewayId: data.gatewayId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.gatewayId
     * @param data.cursor
     * @param data.limit
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static aiGatewayLogs(data: $OpenApiTs['/aiGateway/logs']['get']['req']): CancelablePromise<$OpenApiTs['/aiGateway/logs']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/aiGateway/logs',
            query: {
                workspaceId: data.workspaceId,
                gatewayId: data.gatewayId,
                cursor: data.cursor,
                limit: data.limit
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
}

export class AiGatewayService {
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static aiGatewayAll(data: $OpenApiTs['/workspace/{workspaceId}/aiGateway/all']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/aiGateway/all']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/aiGateway/all',
            path: {
                workspaceId: data.workspaceId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
}

export class ApplicationService {
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static aiGatewayCreate(data: $OpenApiTs['/workspace/{workspaceId}/aiGateway/create']['post']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/aiGateway/create']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/workspace/{workspaceId}/aiGateway/create',
            path: {
                workspaceId: data.workspaceId
            },
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static applicationAll(data: $OpenApiTs['/workspace/{workspaceId}/application/all']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/application/all']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/application/all',
            path: {
                workspaceId: data.workspaceId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.applicationId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static applicationInfo(data: $OpenApiTs['/workspace/{workspaceId}/application/{applicationId}/info']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/application/{applicationId}/info']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/application/{applicationId}/info',
            path: {
                workspaceId: data.workspaceId,
                applicationId: data.applicationId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static applicationCreate(data: $OpenApiTs['/workspace/{workspaceId}/application/create']['post']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/application/create']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/workspace/{workspaceId}/application/create',
            path: {
                workspaceId: data.workspaceId
            },
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.applicationId
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static applicationUpdate(data: $OpenApiTs['/workspace/{workspaceId}/application/{applicationId}/update']['patch']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/application/{applicationId}/update']['patch']['res'][200]> {
        return __request(OpenAPI, {
            method: 'PATCH',
            url: '/workspace/{workspaceId}/application/{applicationId}/update',
            path: {
                workspaceId: data.workspaceId,
                applicationId: data.applicationId
            },
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.applicationId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static applicationDelete(data: $OpenApiTs['/workspace/{workspaceId}/application/{applicationId}/delete']['delete']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/application/{applicationId}/delete']['delete']['res'][200]> {
        return __request(OpenAPI, {
            method: 'DELETE',
            url: '/workspace/{workspaceId}/application/{applicationId}/delete',
            path: {
                workspaceId: data.workspaceId,
                applicationId: data.applicationId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.keyword
     * @param data.storeType
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static applicationStoreAppSearch(data: $OpenApiTs['/application/storeAppSearch']['get']['req']): CancelablePromise<$OpenApiTs['/application/storeAppSearch']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/application/storeAppSearch',
            query: {
                workspaceId: data.workspaceId,
                keyword: data.keyword,
                storeType: data.storeType
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.applicationId
     * @param data.storeType
     * @param data.startAt
     * @param data.endAt
     * @param data.storeId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static applicationStoreInfoHistory(data: $OpenApiTs['/workspace/{workspaceId}/application/{applicationId}/storeInfoHistory']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/application/{applicationId}/storeInfoHistory']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/application/{applicationId}/storeInfoHistory',
            path: {
                workspaceId: data.workspaceId,
                applicationId: data.applicationId
            },
            query: {
                storeType: data.storeType,
                storeId: data.storeId,
                startAt: data.startAt,
                endAt: data.endAt
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.applicationId
     * @param data.startAt
     * @param data.endAt
     * @param data.timezone
     * @param data.unit
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static applicationEventStats(data: $OpenApiTs['/workspace/{workspaceId}/application/{applicationId}/eventStats']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/application/{applicationId}/eventStats']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/application/{applicationId}/eventStats',
            path: {
                workspaceId: data.workspaceId,
                applicationId: data.applicationId
            },
            query: {
                startAt: data.startAt,
                endAt: data.endAt,
                timezone: data.timezone,
                unit: data.unit
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
}

export class GlobalService {
    /**
     * Get Tianji system global config
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static globalConfig(): CancelablePromise<$OpenApiTs['/global/config']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/global/config',
            errors: {
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
}

export class UserService {
    /**
     * @param data The data for the request.
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static userLogin(data: $OpenApiTs['/login']['post']['req']): CancelablePromise<$OpenApiTs['/login']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/login',
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static userLoginWithToken(data: $OpenApiTs['/loginWithToken']['post']['req']): CancelablePromise<$OpenApiTs['/loginWithToken']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/loginWithToken',
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
}

export class WorkspaceService {
    /**
     * @param data The data for the request.
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static workspaceCreate(data: $OpenApiTs['/workspace/create']['post']['req']): CancelablePromise<$OpenApiTs['/workspace/create']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/workspace/create',
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static workspaceSwitch(data: $OpenApiTs['/workspace/switch']['post']['req']): CancelablePromise<$OpenApiTs['/workspace/switch']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/workspace/switch',
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static workspaceRename(data: $OpenApiTs['/workspace/rename']['patch']['req']): CancelablePromise<$OpenApiTs['/workspace/rename']['patch']['res'][200]> {
        return __request(OpenAPI, {
            method: 'PATCH',
            url: '/workspace/rename',
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static workspaceDelete(data: $OpenApiTs['/workspace/{workspaceId}/del']['delete']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/del']['delete']['res'][200]> {
        return __request(OpenAPI, {
            method: 'DELETE',
            url: '/workspace/{workspaceId}/del',
            path: {
                workspaceId: data.workspaceId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static workspaceMembers(data: $OpenApiTs['/workspace/{workspaceId}/members']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/members']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/members',
            path: {
                workspaceId: data.workspaceId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static workspaceUpdateSettings(data: $OpenApiTs['/workspace/{workspaceId}/updateSettings']['post']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/updateSettings']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/workspace/{workspaceId}/updateSettings',
            path: {
                workspaceId: data.workspaceId
            },
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static workspaceInvite(data: $OpenApiTs['/workspace/{workspaceId}/invite']['post']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/invite']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/workspace/{workspaceId}/invite',
            path: {
                workspaceId: data.workspaceId
            },
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * Administrator kicks a user out of a workspace.
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.targetUserId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static workspaceTick(data: $OpenApiTs['/workspace/{workspaceId}/tick']['delete']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/tick']['delete']['res'][200]> {
        return __request(OpenAPI, {
            method: 'DELETE',
            url: '/workspace/{workspaceId}/tick',
            path: {
                workspaceId: data.workspaceId
            },
            query: {
                targetUserId: data.targetUserId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * Update workspace member role
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static workspaceUpdateMemberRole(data: $OpenApiTs['/workspace/{workspaceId}/updateMemberRole']['patch']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/updateMemberRole']['patch']['res'][200]> {
        return __request(OpenAPI, {
            method: 'PATCH',
            url: '/workspace/{workspaceId}/updateMemberRole',
            path: {
                workspaceId: data.workspaceId
            },
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static workspaceGetServiceCount(data: $OpenApiTs['/workspace/{workspaceId}/getServiceCount']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/getServiceCount']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/getServiceCount',
            path: {
                workspaceId: data.workspaceId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
}

export class WebsiteService {
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.websiteId
     * @returns number Successful response
     * @throws ApiError
     */
    public static websiteOnlineCount(data: $OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/onlineCount']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/onlineCount']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/website/{websiteId}/onlineCount',
            path: {
                workspaceId: data.workspaceId,
                websiteId: data.websiteId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static websiteAll(data: $OpenApiTs['/workspace/{workspaceId}/website/all']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/all']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/website/all',
            path: {
                workspaceId: data.workspaceId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @returns number Successful response
     * @throws ApiError
     */
    public static websiteAllOverview(data: $OpenApiTs['/workspace/{workspaceId}/website/allOverview']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/allOverview']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/website/allOverview',
            path: {
                workspaceId: data.workspaceId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.websiteId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static websiteInfo(data: $OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/info']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/info']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/website/{websiteId}/info',
            path: {
                workspaceId: data.workspaceId,
                websiteId: data.websiteId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.websiteId
     * @param data.startAt
     * @param data.endAt
     * @param data.unit
     * @param data.url
     * @param data.country
     * @param data.region
     * @param data.city
     * @param data.timezone
     * @param data.referrer
     * @param data.title
     * @param data.os
     * @param data.browser
     * @param data.device
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static websiteStats(data: $OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/stats']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/stats']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/website/{websiteId}/stats',
            path: {
                workspaceId: data.workspaceId,
                websiteId: data.websiteId
            },
            query: {
                startAt: data.startAt,
                endAt: data.endAt,
                unit: data.unit,
                url: data.url,
                country: data.country,
                region: data.region,
                city: data.city,
                timezone: data.timezone,
                referrer: data.referrer,
                title: data.title,
                os: data.os,
                browser: data.browser,
                device: data.device
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.websiteId
     * @param data.startAt
     * @param data.endAt
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static websiteGeoStats(data: $OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/geoStats']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/geoStats']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/website/{websiteId}/geoStats',
            path: {
                workspaceId: data.workspaceId,
                websiteId: data.websiteId
            },
            query: {
                startAt: data.startAt,
                endAt: data.endAt
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.websiteId
     * @param data.startAt
     * @param data.endAt
     * @param data.unit
     * @param data.url
     * @param data.country
     * @param data.region
     * @param data.city
     * @param data.timezone
     * @param data.referrer
     * @param data.title
     * @param data.os
     * @param data.browser
     * @param data.device
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static websitePageviews(data: $OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/pageviews']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/pageviews']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/website/{websiteId}/pageviews',
            path: {
                workspaceId: data.workspaceId,
                websiteId: data.websiteId
            },
            query: {
                startAt: data.startAt,
                endAt: data.endAt,
                unit: data.unit,
                url: data.url,
                country: data.country,
                region: data.region,
                city: data.city,
                timezone: data.timezone,
                referrer: data.referrer,
                title: data.title,
                os: data.os,
                browser: data.browser,
                device: data.device
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.websiteId
     * @param data.type
     * @param data.startAt
     * @param data.endAt
     * @param data.url
     * @param data.referrer
     * @param data.title
     * @param data.os
     * @param data.browser
     * @param data.device
     * @param data.country
     * @param data.region
     * @param data.city
     * @param data.language
     * @param data.event
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static websiteMetrics(data: $OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/metrics']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/metrics']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/website/{websiteId}/metrics',
            path: {
                workspaceId: data.workspaceId,
                websiteId: data.websiteId
            },
            query: {
                type: data.type,
                startAt: data.startAt,
                endAt: data.endAt,
                url: data.url,
                referrer: data.referrer,
                title: data.title,
                os: data.os,
                browser: data.browser,
                device: data.device,
                country: data.country,
                region: data.region,
                city: data.city,
                language: data.language,
                event: data.event
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static websiteAdd(data: $OpenApiTs['/workspace/{workspaceId}/website/add']['post']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/add']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/workspace/{workspaceId}/website/add',
            path: {
                workspaceId: data.workspaceId
            },
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.websiteId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static websiteDelete(data: $OpenApiTs['/workspace/{workspaceId}/website/{websiteId}']['delete']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/{websiteId}']['delete']['res'][200]> {
        return __request(OpenAPI, {
            method: 'DELETE',
            url: '/workspace/{workspaceId}/website/{websiteId}',
            path: {
                workspaceId: data.workspaceId,
                websiteId: data.websiteId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.websiteId
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static websiteUpdateInfo(data: $OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/update']['put']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/update']['put']['res'][200]> {
        return __request(OpenAPI, {
            method: 'PUT',
            url: '/workspace/{workspaceId}/website/{websiteId}/update',
            path: {
                workspaceId: data.workspaceId,
                websiteId: data.websiteId
            },
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.websiteId
     * @param data.requestBody
     * @returns string Successful response
     * @throws ApiError
     */
    public static websiteGenerateLighthouseReport(data: $OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/generateLighthouseReport']['post']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/generateLighthouseReport']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/workspace/{workspaceId}/website/{websiteId}/generateLighthouseReport',
            path: {
                workspaceId: data.workspaceId,
                websiteId: data.websiteId
            },
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.websiteId
     * @param data.limit
     * @param data.cursor
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static websiteGetLighthouseReport(data: $OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/getLighthouseReport']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/website/{websiteId}/getLighthouseReport']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/website/{websiteId}/getLighthouseReport',
            path: {
                workspaceId: data.workspaceId,
                websiteId: data.websiteId
            },
            query: {
                limit: data.limit,
                cursor: data.cursor
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.lighthouseId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static websiteGetLighthouseJson(data: $OpenApiTs['/lighthouse/{lighthouseId}']['get']['req']): CancelablePromise<$OpenApiTs['/lighthouse/{lighthouseId}']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/lighthouse/{lighthouseId}',
            path: {
                lighthouseId: data.lighthouseId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
}

export class MonitorService {
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static monitorAll(data: $OpenApiTs['/workspace/{workspaceId}/monitor/all']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/monitor/all']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/monitor/all',
            path: {
                workspaceId: data.workspaceId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.monitorId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static monitorGet(data: $OpenApiTs['/workspace/{workspaceId}/monitor/{monitorId}/get']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/monitor/{monitorId}/get']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/monitor/{monitorId}/get',
            path: {
                workspaceId: data.workspaceId,
                monitorId: data.monitorId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static monitorGetPublicInfo(data: $OpenApiTs['/monitor/getPublicInfo']['post']['req']): CancelablePromise<$OpenApiTs['/monitor/getPublicInfo']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/monitor/getPublicInfo',
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static monitorUpsert(data: $OpenApiTs['/workspace/{workspaceId}/monitor/upsert']['post']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/monitor/upsert']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/workspace/{workspaceId}/monitor/upsert',
            path: {
                workspaceId: data.workspaceId
            },
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.monitorId
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static monitorDelete(data: $OpenApiTs['/workspace/{workspaceId}/monitor/{monitorId}/del']['delete']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/monitor/{monitorId}/del']['delete']['res'][200]> {
        return __request(OpenAPI, {
            method: 'DELETE',
            url: '/workspace/{workspaceId}/monitor/{monitorId}/del',
            path: {
                workspaceId: data.workspaceId,
                monitorId: data.monitorId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.monitorId
     * @returns string Successful response
     * @throws ApiError
     */
    public static monitorRegeneratePushToken(data: $OpenApiTs['/workspace/{workspaceId}/monitor/{monitorId}/regeneratePushToken']['post']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/monitor/{monitorId}/regeneratePushToken']['post']['res'][200]> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/workspace/{workspaceId}/monitor/{monitorId}/regeneratePushToken',
            path: {
                workspaceId: data.workspaceId,
                monitorId: data.monitorId
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.monitorId
     * @param data.startAt
     * @param data.endAt
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static monitorData(data: $OpenApiTs['/workspace/{workspaceId}/monitor/{monitorId}/data']['get']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/monitor/{monitorId}/data']['get']['res'][200]> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/workspace/{workspaceId}/monitor/{monitorId}/data',
            path: {
                workspaceId: data.workspaceId,
                monitorId: data.monitorId
            },
            query: {
                startAt: data.startAt,
                endAt: data.endAt
            },
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.workspaceId
     * @param data.monitorId
     * @param data.requestBody
     * @returns unknown Successful response
     * @throws ApiError
     */
    public static monitorChangeActive(data: $OpenApiTs['/workspace/{workspaceId}/monitor/{monitorId}/changeActive']['patch']['req']): CancelablePromise<$OpenApiTs['/workspace/{workspaceId}/monitor/{monitorId}/changeActive']['patch']['res'][200]> {
        return __request(OpenAPI, {
            method: 'PATCH',
            url: '/workspace/{workspaceId}/monitor/{monitorId}/changeActive',
            path: {
                workspaceId: data.workspaceId,
                monitorId: data.monitorId
            },
            body: data.requestBody,
            mediaType: 'application/json',
            errors: {
                400: 'Invalid input data',
                401: 'Authorization not provided',
                403: 'Insufficient access',
                404: 'Not found',
                500: 'Internal server error'
            }
        });
    }
    
    /**
     * @param data The data for the request.
     * @param data.