@atlassian-dc-mcp/confluence 0.1.3 → 0.2.0

package/src/confluence-client/services/AttachmentsService.ts

@@ -0,0 +1,287 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Content } from '../models/Content.js';
+import type { MockAttachmentRequest } from '../models/MockAttachmentRequest.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class AttachmentsService {
+    /**
+     * Get attachment
+     * Returns a paginated list of attachment Content entities within a single container.
+     * @param id The id of the content the attachment is on.
+     * @param expand (optional) a comma separated list of properties to expand on the Attachments returned. Optional.
+     * @param filename (optional) filter parameter to return only the Attachment with the matching file name.
+     * @param limit (optional) how many items should be returned after the start index.
+     * @param start (optional) the index of the first item within the result set that should be returned.
+     * @param mediaType (optional) a comma separated list of properties to expand on the Attachments returned.
+     * @returns any Returns a JSON representation of a list of attachment Content entities.
+     * @throws ApiError
+     */
+    public static getAttachments(
+        id: string,
+        expand?: string,
+        filename?: string,
+        limit?: string,
+        start?: string,
+        mediaType?: string,
+    ): CancelablePromise<{
+        results?: Array<Content>;
+        totalCount?: number;
+        start?: number;
+        limit?: number;
+        size?: number;
+        _links?: {
+            base?: string;
+            context?: string;
+            self?: string;
+            next?: string;
+            prev?: string;
+        };
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/content/{id}/child/attachment',
+            path: {
+                'id': id,
+            },
+            query: {
+                'expand': expand,
+                'filename': filename,
+                'limit': limit,
+                'start': start,
+                'mediaType': mediaType,
+            },
+            errors: {
+                404: ` Returned if there is no content with the given id, or if the calling user does not have permission to view the content.`,
+            },
+        });
+    }
+    /**
+     * Create attachments
+     * Add one or more attachments to a Confluence Content entity, with optional comments.
+     *
+     * **Comments are optional**, but if included there must be as many comments as there are files, and the comments must be in the same order as the files.
+     *
+     * This resource expects a multipart post. The media-type multipart/form-data is defined in RFC 1867. Most client libraries have classes that make dealing with multipart posts simple. For instance, in Java the Apache HTTP Components library provides a `MultiPartEntity` that makes it simple to submit a multipart POST.
+     *
+     * In order to protect against XSRF attacks, because this method accepts multipart/form-data, it has XSRF protection on it. This means you must submit a header of `X-Atlassian-Token: nocheck` with the request, otherwise it will be blocked.
+     *
+     * The name of the multipart/form-data parameter that contains attachments must be 'file'.
+     * @param id The id of the content the attachment is on.
+     * @param expand (optional) a comma separated list of properties to expand on the Attachments returned. Optional.
+     * @param allowDuplicated (optional) allows to upload an attachment with an existing filename.
+     * @param status a string containing the status of the attachments content container, supports current or draft, defaults to current
+     * @param formData The attachments to be added. The name of the multipart/form-data parameter that contains attachments must be 'file'.
+     * @returns Content returns a JSON representation of the attachments added.
+     * @throws ApiError
+     */
+    public static createAttachments(
+        id: string,
+        expand?: string,
+        allowDuplicated?: string,
+        status?: string,
+        formData?: MockAttachmentRequest,
+    ): CancelablePromise<Content> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/content/{id}/child/attachment',
+            path: {
+                'id': id,
+            },
+            query: {
+                'expand': expand,
+                'allowDuplicated': allowDuplicated,
+                'status': status,
+            },
+            formData: formData,
+            mediaType: 'multipart/form-data',
+            errors: {
+                403: `Returned if attachments is disabled or if you don't have permission to add attachments to this content.`,
+                404: ` Returned if the requested content is not found, the user does not have permission to view it, or if the attachments exceeds the maximum configured attachment size.`,
+            },
+        });
+    }
+    /**
+     * Move attachment
+     * Move an attachment to a different content entity object.
+     *
+     * **When moving the attachment**, the name of the attachment can be updated as well.
+     *
+     * In order to protect against XSRF attacks, because this method accepts multipart/form-data, it has XSRF protection on it. This means you must submit a header of `X-Atlassian-Token: nocheck` with the request, otherwise it will be blocked.
+     *
+     * A simple example to move an attachment with id "456" in a container with id "123" to a container with "789":
+     *
+     * `curl -D- -u admin:admin -X POST -H "X-Atlassian-Token: nocheck" "http://myhost/rest/api/content/123/child/attachment/456/move?newContentId=789"`
+     *
+     * An example to move the same file, while also renaming it to "my-new-name":
+     *
+     * `curl -D- -u admin:admin -X POST -H "X-Atlassian-Token: nocheck" "http://myhost/rest/api/content/123/child/attachment/456/move?newContentId=789&newName=my-new-name"`
+     *
+     * This can also be used to only rename an attachment:
+     *
+     * `curl -D- -u admin:admin -X POST -H "X-Atlassian-Token: nocheck" "http://myhost/rest/api/content/123/child/attachment/456/move?newContentId=123&newName=my-new-name"`
+     * @param attachmentId the id of the attachment to upload the new file for.
+     * @param id The id of the content the attachment is on.
+     * @param newName
+     * @param newContentId
+     * @returns void
+     * @throws ApiError
+     */
+    public static move(
+        attachmentId: string,
+        id: string,
+        newName?: string,
+        newContentId?: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/content/{id}/child/attachment/{attachmentId}/move',
+            path: {
+                'attachmentId': attachmentId,
+                'id': id,
+            },
+            query: {
+                'newName': newName,
+                'newContentId': newContentId,
+            },
+            errors: {
+                400: ` Returned if the attachment id is invalid.`,
+                404: ` Returned if no attachment is found for the attachmentId.`,
+            },
+        });
+    }
+    /**
+     * Update non-binary data of an Attachment
+     * Update the non-binary data of an attachment.This resource can be used to update an attachment's filename, media-type, comment, and parent container.
+     * @param attachmentId the id of the attachment to update.
+     * @param id The id of the content the attachment is on.
+     * @param requestBody
+     * @returns Content returns a JSON representation of the attachment after being updated.
+     * @throws ApiError
+     */
+    public static update(
+        attachmentId: string,
+        id: string,
+        requestBody?: Content,
+    ): CancelablePromise<Content> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/rest/api/content/{id}/child/attachment/{attachmentId}',
+            path: {
+                'attachmentId': attachmentId,
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: ` Returned if the attachment id or the attachment version number are invalid.`,
+                403: `Returned if you are not permitted to update or move the attachment to a different container.`,
+                404: ` Returned if no attachment is found for the attachmentId.`,
+                409: `Returned if the version of the supplied Attachment does not match the exact version of the Attachment stored in the database.`,
+            },
+        });
+    }
+    /**
+     * Remove attachment
+     * This method will delete the attachment identified by attachmentId.
+     *
+     * It returns a boolean response indicating whether the operation was successful or not. If the specified attachment or version does not exist, or if the user does not have permission to remove the attachment, appropriate exceptions are thrown and mapped to their corresponding HTTP responses.
+     * @param attachmentId the id of the attachment to be removed.
+     * @param id The id of the content the attachment is on.
+     * @returns void
+     * @throws ApiError
+     */
+    public static removeAttachment(
+        attachmentId: string,
+        id: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/rest/api/content/{id}/child/attachment/{attachmentId}',
+            path: {
+                'attachmentId': attachmentId,
+                'id': id,
+            },
+            errors: {
+                400: `Returned if the user does not have permission to remove the attachment.`,
+                404: ` Returned if the specified attachment does not exist.`,
+            },
+        });
+    }
+    /**
+     * Remove attachment version
+     * This method will delete the specified version of an attachment identified by attachmentId and version.
+     *
+     * If the operation is successful, it returns a response indicating that no content is returned. If the specified attachment or version does not exist, or if the user does not have permission to remove the attachment, appropriate exceptions are thrown and mapped to their corresponding HTTP responses.
+     * @param attachmentId The id of the attachment to be removed.
+     * @param id The id of the content the attachment is on.
+     * @param version
+     * @returns void
+     * @throws ApiError
+     */
+    public static removeAttachmentVersion(
+        attachmentId: string,
+        id: string,
+        version: number,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/rest/api/content/{id}/child/attachment/{attachmentId}/version/{version}',
+            path: {
+                'attachmentId': attachmentId,
+                'id': id,
+                'version': version,
+            },
+            errors: {
+                400: `Returned if the user does not have permission to remove the attachment.`,
+                404: `Returned if the specified attachment or version does not exist.`,
+            },
+        });
+    }
+    /**
+     * Update binary data of an attachment
+     * Update the binary data of an Attachment, and optionally the comment and the minor edit field.
+     *
+     * This adds a new version of the attachment, containing the new binary data, filename, and content-type.
+     *
+     * **When updating the binary data of an attachment**, the comment related to it together with the field that specifies if it's a minor edit can be updated as well, but are not required.
+     *
+     * If an update is considered to be a minor edit, notifications will not be sent to the watchers of that content.
+     *
+     * This resource expects a multipart post. The media-type multipart/form-data is defined in RFC 1867. Most client libraries have classes that make dealing with multipart posts simple. For instance, in Java the Apache HTTP Components library provides a `MultiPartEntity` that makes it simple to submit a multipart POST.
+     *
+     * In order to protect against XSRF attacks, because this method accepts multipart/form-data, it has XSRF protection on it. This means you must submit a header of `X-Atlassian-Token: nocheck` with the request, otherwise it will be blocked.
+     *
+     * The name of the multipart/form-data parameter that contains attachments must be 'file'.
+     * @param attachmentId the id of the attachment to upload the new file for.
+     * @param id The id of the content the attachment is on.
+     * @param formData The attachment to be updated.
+     * @returns Content returns JSON representation of the updated attachment.
+     * @throws ApiError
+     */
+    public static updateData(
+        attachmentId: string,
+        id: string,
+        formData?: MockAttachmentRequest,
+    ): CancelablePromise<Content> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/content/{id}/child/attachment/{attachmentId}/data',
+            path: {
+                'attachmentId': attachmentId,
+                'id': id,
+            },
+            formData: formData,
+            mediaType: 'multipart/form-data',
+            errors: {
+                400: ` Returned if the attachment id is invalid.`,
+                404: ` Returned if no attachment is found for the attachmentId.`,
+            },
+        });
+    }
+}
+
+

package/src/confluence-client/services/BackupAndRestoreService.ts

@@ -0,0 +1,320 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ExampleMultipartFormData } from '../models/ExampleMultipartFormData.js';
+import type { FileInfo } from '../models/FileInfo.js';
+import type { JobDetails } from '../models/JobDetails.js';
+import type { SiteBackupJobDetails } from '../models/SiteBackupJobDetails.js';
+import type { SiteBackupSettings } from '../models/SiteBackupSettings.js';
+import type { SiteRestoreJobDetails } from '../models/SiteRestoreJobDetails.js';
+import type { SiteRestoreSettings } from '../models/SiteRestoreSettings.js';
+import type { SpaceBackupJobDetails } from '../models/SpaceBackupJobDetails.js';
+import type { SpaceBackupSettings } from '../models/SpaceBackupSettings.js';
+import type { SpaceRestoreJobDetails } from '../models/SpaceRestoreJobDetails.js';
+import type { SpaceRestoreSettings } from '../models/SpaceRestoreSettings.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class BackupAndRestoreService {
+    /**
+     * Cancel all queued jobs
+     * Cancels all queued jobs. Does not affect jobs that are being processed at the moment.
+     * @returns any Returns the number of cancelled jobs. If no jobs were cancelled, 0 is returned.
+     * Example response: `1`
+     * @throws ApiError
+     */
+    public static cancelAllQueuedJobs(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/rest/api/backup-restore/jobs/clear-queue',
+            errors: {
+                403: `Returned if user doesn't have permission to cancel jobs`,
+            },
+        });
+    }
+    /**
+     * Cancel job
+     * Cancels the job. If the job is already cancelled or failed, the method will do nothing.
+     * @param jobId id of the backup/restore job
+     * @returns JobDetails Returns a JSON representation of the cancelled job.
+     * @throws ApiError
+     */
+    public static cancelJob(
+        jobId: string,
+    ): CancelablePromise<JobDetails> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/rest/api/backup-restore/jobs/{jobId}/cancel',
+            path: {
+                'jobId': jobId,
+            },
+            errors: {
+                404: `Returned if job not found or user doesn't have permission to cancel it`,
+            },
+        });
+    }
+    /**
+     * Create site backup job
+     * Starts the new site backup job.
+     * @param requestBody Site backup settings
+     * @returns SiteBackupJobDetails Returns a JSON representation of the site backup job details.
+     * @throws ApiError
+     */
+    public static createSiteBackupJob(
+        requestBody?: SiteBackupSettings,
+    ): CancelablePromise<SiteBackupJobDetails> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/backup-restore/backup/site',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: ` Returned if invalid settings provided`,
+                409: `Returned if user doesn't have permission to create site backups`,
+            },
+        });
+    }
+    /**
+     * Create site restore job
+     * Starts the new site restore job.
+     * @param requestBody space restore settings
+     * @returns SiteRestoreJobDetails Returns a JSON representation of the site restore job.
+     * @throws ApiError
+     */
+    public static createSiteRestoreJob(
+        requestBody?: SiteRestoreSettings,
+    ): CancelablePromise<SiteRestoreJobDetails> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/backup-restore/restore/site',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: ` Returned if invalid filename provided`,
+                403: `Returned if user doesn't have permission to restore site`,
+            },
+        });
+    }
+    /**
+     * Create site restore job for upload backup file
+     * This resource expects a multipart post. The media-type multipart/form-data is defined in RFC 1867.
+     *
+     * Most client libraries have classes that make dealing with multipart posts simple.
+     *
+     * For instance, in Java the Apache HTTP Components library provides a MultiPartEntity that makes it simple to submit a multipart POST.
+     *
+     * In order to protect against XSRF attacks, because this method accepts multipart/form-data, it has XSRF protection on it.  This means you must submit a header of X-Atlassian-Token: nocheck with the request, otherwise it will be blocked.
+     *
+     * The name of the multipart/form-data parameter that contains attachments must be "file".
+     *
+     * An example to attach the file:
+     *
+     * curl -D- -u admin:admin -X POST -H "X-Atlassian-Token: nocheck" -F  file=@myfile.zip http://myhost/rest/api/backup-restore/restore/space/upload
+     *
+     * .
+     * @param formData Backup file to be uploaded. Has to be a zip file.
+     * @returns SiteRestoreJobDetails Returns a JSON representation of the site restore job details.
+     * @throws ApiError
+     */
+    public static createSiteRestoreJobForUploadedBackupFile(
+        formData?: ExampleMultipartFormData,
+    ): CancelablePromise<SiteRestoreJobDetails> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/backup-restore/restore/site/upload',
+            formData: formData,
+            mediaType: 'multipart/form-data',
+            errors: {
+                400: ` Returned if the uploaded file is not a zip file`,
+                403: ` Returned if user doesn't have permission to restore space`,
+            },
+        });
+    }
+    /**
+     * Create space backup job
+     * Creates new space backup job and adds it to the queue.
+     * @param requestBody Space backup settings
+     * @returns SpaceBackupJobDetails Returns a JSON representation of the space backup job
+     * @throws ApiError
+     */
+    public static createSpaceBackupJob(
+        requestBody?: SpaceBackupSettings,
+    ): CancelablePromise<SpaceBackupJobDetails> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/backup-restore/backup/space',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if invalid settings provided`,
+                403: `Returned if user doesn't have permission to create space backups`,
+                409: `Returned if backup with the same spaces selected is already in PROGRESS or QUEUED`,
+            },
+        });
+    }
+    /**
+     * Create space restore job
+     * Creates new space restore job and adds it to the queue.
+     * @param requestBody space restore settings
+     * @returns SpaceRestoreJobDetails Returns a JSON representation of the space restore job.
+     * @throws ApiError
+     */
+    public static createSpaceRestoreJob(
+        requestBody?: SpaceRestoreSettings,
+    ): CancelablePromise<SpaceRestoreJobDetails> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/backup-restore/restore/space',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: ` Returned if invalid filename provided`,
+                403: `Returned if user doesn't have permission to restore spaces`,
+            },
+        });
+    }
+    /**
+     * Create space restore job for upload backup file
+     * This resource expects a multipart post. The media-type multipart/form-data is defined in RFC 1867.
+     *
+     * Most client libraries have classes that make dealing with multipart posts simple.
+     *
+     * For instance, in Java the Apache HTTP Components library provides a MultiPartEntity that makes it simple to submit a multipart POST.
+     *
+     * In order to protect against XSRF attacks, because this method accepts multipart/form-data, it has XSRF protection on it.  This means you must submit a header of X-Atlassian-Token: nocheck with the request, otherwise it will be blocked.
+     *
+     * The name of the multipart/form-data parameter that contains attachments must be "file".
+     *
+     * An example to attach the file:
+     *
+     * curl -D- -u admin:admin -X POST -H "X-Atlassian-Token: nocheck" -F  file=@myfile.zip http://myhost/rest/api/backup-restore/restore/space/upload
+     *
+     * .
+     * @param formData backup file uploaded. Has to be a zip file.
+     * @returns SpaceRestoreJobDetails Returns a JSON representation of the space restore job details.
+     * @throws ApiError
+     */
+    public static createSpaceRestoreJobForUploadedBackupFile(
+        formData?: ExampleMultipartFormData,
+    ): CancelablePromise<SpaceRestoreJobDetails> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/backup-restore/restore/space/upload',
+            formData: formData,
+            mediaType: 'multipart/form-data',
+            errors: {
+                400: ` Returned if the uploaded file is not a zip file`,
+                403: ` Returned if user doesn't have permission to restore space`,
+            },
+        });
+    }
+    /**
+     * Download backup file
+     * Downloads the backup file for the given job. Requires site admin or space export permissions for all spaces included in the backup job.
+     * @param jobId id of the backup/restore job
+     * @returns JobDetails Returns a data stream of the backup file content.
+     * @throws ApiError
+     */
+    public static downloadBackupFile(
+        jobId: string,
+    ): CancelablePromise<JobDetails> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/backup-restore/jobs/{jobId}/download',
+            path: {
+                'jobId': jobId,
+            },
+            errors: {
+                404: `Returned if job not found or user doesn't have permissions for the job or the file is missing`,
+            },
+        });
+    }
+    /**
+     * Find jobs by filters
+     * Returns jobs based on the filters provided. The user must have permission to see the jobs.
+     * @param owner userName of user who had created a job.
+     * @param spaceKey the key of the Space the User is attempting to view.
+     * @param fromDate minimum job creation date. Supported date format is `yyyy-MM-ddTHH:mm:ss.SSSZ`
+     * @param jobStates list of job states. Acceptable values: "QUEUED", "PROCESSING", "FINISHED", "CANCELLING", "CANCELLED", "FAILED"
+     * @param toDate maximum job create date. Supported date format is `yyyy-MM-ddTHH:mm:ss.SSSZ`
+     * @param jobOperation job operation. Acceptable values: "BACKUP" and "RESTORE"
+     * @param limit amount of jobs that should be returned
+     * @param jobScope scope of the job. Acceptable values: "SPACE" and "SITE"
+     * @returns JobDetails Returns the List of backup/restore jobs visible to user based on the filter provided and the user's permissions.
+     * @throws ApiError
+     */
+    public static findJobs(
+        owner?: string,
+        spaceKey?: string,
+        fromDate?: string,
+        jobStates?: string,
+        toDate?: string,
+        jobOperation?: string,
+        limit?: string,
+        jobScope?: string,
+    ): CancelablePromise<Array<JobDetails>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/backup-restore/jobs',
+            query: {
+                'owner': owner,
+                'spaceKey': spaceKey,
+                'fromDate': fromDate,
+                'jobStates': jobStates,
+                'toDate': toDate,
+                'jobOperation': jobOperation,
+                'limit': limit,
+                'jobScope': jobScope,
+            },
+            errors: {
+                400: `Returned if invalid filter parameters were passed`,
+            },
+        });
+    }
+    /**
+     * Get files in restore directory
+     * returns list of information on files in conf-home/restore/(jobScope).
+     * @param jobScope name of type of restore job (SITE or SPACE or null), if null, all backup files are listed
+     * @returns FileInfo Returns a list of FileInfo objects, containing fileName, fileCreationTime, fileSize, and jobScope.
+     * @throws ApiError
+     */
+    public static getFiles(
+        jobScope?: string,
+    ): CancelablePromise<Array<FileInfo>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/backup-restore/restore/files',
+            query: {
+                'jobScope': jobScope,
+            },
+            errors: {
+                400: `Returned if user is not a system administrator`,
+            },
+        });
+    }
+    /**
+     * Get job by ID
+     * Get job by id. The user must be a sysadmin or the owner of the job.
+     * @param jobId id of the backup/restore job
+     * @returns JobDetails Returns a JSON representation of the backup/restore job
+     * @throws ApiError
+     */
+    public static getJob(
+        jobId: string,
+    ): CancelablePromise<JobDetails> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/backup-restore/jobs/{jobId}',
+            path: {
+                'jobId': jobId,
+            },
+            errors: {
+                400: ` Returned if jobId is null`,
+                403: ` Returned if job not found or user doesn't have permission to see it`,
+            },
+        });
+    }
+}
+
+

package/src/confluence-client/services/CategoryService.ts

@@ -0,0 +1,70 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class CategoryService {
+    /**
+     * Add a category to a space
+     * Adds a category the description of a given {@link Space} identified by spaceKey.
+     *
+     * Example request URI to add space category 'testCategory' to space with space key TEST:
+     *
+     * `https://example.com/confluence/rest/api/space/TEST/category/testCategory`
+     * @param spaceKey a string containing the key of the space
+     * @param labelName the name of the label to be added (do not include any prefix, team: prefix assumed)
+     * @returns void
+     * @throws ApiError
+     */
+    public static add(
+        spaceKey: string,
+        labelName: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/space/{spaceKey}/category/{labelName}',
+            path: {
+                'spaceKey': spaceKey,
+                'labelName': labelName,
+            },
+            errors: {
+                401: `Returned if the calling user is not authenticated.`,
+                403: `If the calling user does not have permission to add any label to the given space.`,
+                404: `Returned if there is no space with the given spaceKey.`,
+            },
+        });
+    }
+    /**
+     * Remove a category from a space
+     * Removes a category from a space, identified by spaceKey.
+     *
+     * Example request URI:
+     * `https://example.com/confluence/rest/api/space/TEST/category/example-category`
+     * @param spaceKey The key of the space to remove the category from
+     * @param categoryName The name of the category to remove
+     * @returns void
+     * @throws ApiError
+     */
+    public static removeCategory(
+        spaceKey: string,
+        categoryName: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/rest/api/space/{spaceKey}/category/{categoryName}',
+            path: {
+                'spaceKey': spaceKey,
+                'categoryName': categoryName,
+            },
+            errors: {
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to edit the Space.`,
+                404: `Returned if there is no space with the given key`,
+            },
+        });
+    }
+}
+
+