@atlassian-dc-mcp/confluence 0.1.4 → 0.3.0

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

@@ -0,0 +1,57 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Group } from '../models/Group.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class AdminGroupService {
+    /**
+     * Create group
+     * Creates the given group identified by name.
+     * @param requestBody
+     * @returns Group returns the new group if group is created successfully
+     * @throws ApiError
+     */
+    public static create(
+        requestBody?: Group,
+    ): CancelablePromise<Group> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/admin/group',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `returned if request does not provide a name`,
+                403: `returned if user does not have enough permission`,
+                409: `returned if group with the same name already exists`,
+            },
+        });
+    }
+    /**
+     * Delete group
+     * Deletes the given group identified by name.
+     * @param groupName the group name to be deleted
+     * @returns void
+     * @throws ApiError
+     */
+    public static delete(
+        groupName: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/rest/api/admin/group/{groupName}',
+            path: {
+                'groupName': groupName,
+            },
+            errors: {
+                400: `returned if user is attempting to delete the last admin group`,
+                403: `returned if user does not have correct permission`,
+                404: `returned if group cannot be found`,
+            },
+        });
+    }
+}
+
+

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

@@ -0,0 +1,45 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { PersonalSpaceDetailsForCreation } from '../models/PersonalSpaceDetailsForCreation.js';
+import type { Space } from '../models/Space.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class AdminSpaceService {
+    /**
+     * Creates personal Space for a User.
+     * Creates a personal space for a user.
+     *
+     * Example request URI:
+     *
+     * `http://example.com/confluence/rest/api/admin/space/personal/morganlee`
+     * @param username the username of the user to create personal space for.
+     * @param requestBody The personal space to be created
+     * @returns Space Returns a full JSON representation of a space.
+     * @throws ApiError
+     */
+    public static createPersonalSpace(
+        username: string,
+        requestBody: PersonalSpaceDetailsForCreation,
+    ): CancelablePromise<Space> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/admin/space/personal/{username}',
+            path: {
+                'username': username,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if there is invalid space description.`,
+                403: `Returned if current user does not have correct permission.`,
+                404: `Returned if target user not found by username.`,
+                409: `Returned if personal space already exists for target user.`,
+            },
+        });
+    }
+}
+
+

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

@@ -0,0 +1,206 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Credentials } from '../models/Credentials.js';
+import type { LongTaskSubmission } from '../models/LongTaskSubmission.js';
+import type { UserDetailsForCreation } from '../models/UserDetailsForCreation.js';
+import type { UserDetailsForUpdate } from '../models/UserDetailsForUpdate.js';
+import type { UserKey } from '../models/UserKey.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class AdminUserService {
+    /**
+     * Change password
+     * Change the password for the user identified by the username.
+     *
+     * **Validation rules** :
+     *
+     * - The new password should not be null or blank.
+     *
+     *
+     * @param username the username identifying the given user
+     * @param requestBody
+     * @returns void
+     * @throws ApiError
+     */
+    public static changePassword(
+        username: string,
+        requestBody?: Credentials,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/admin/user/{username}/password',
+            path: {
+                'username': username,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `returned if any error occurs while changing user password. Refer to the validation rules above.`,
+                403: `returned if user does not have enough permission to change another user's password. User should be a System admin`,
+                404: `returned if user with specified userName not found`,
+            },
+        });
+    }
+    /**
+     * Create user
+     * One of the following options could be used:
+     *
+     * 1. Create a user with a specified password. The userName, fullName, email and password needs to be specified.
+     *
+     * 2. Create a user with an email notification to the user. The userName, fullName, email and notifyViaEmail (true) needs to be specified.
+     *
+     * **Requirements**:
+     *
+     * - The userName should not be null or blank
+     *
+     * - The userName should not contain any of these characters \ , + < > ' "
+     *
+     * - The userName should not contain any whitespace characters
+     *
+     * - The userName should not be "anonymous"
+     *
+     * - The userName should not contain any upper case characters
+     *
+     * - The fullName should not be null or blank
+     *
+     * - The fullName should not contain any of these characters
+     *
+     * - The fullName should not be "anonymous"
+     *
+     * - The email should not be null or blank
+     *
+     * - The email should be a valid email address
+     *
+     * - If notifyViaEmail is false then the password should not be null or blank
+     *
+     * - If notifyViaEmail is true then the password should not be specified
+     * @param requestBody Details of the user to be created
+     * @returns UserKey returns a response with generated UserKey for the created user.
+     * @throws ApiError
+     */
+    public static createUser(
+        requestBody?: UserDetailsForCreation,
+    ): CancelablePromise<UserKey> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/admin/user',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `returned if any error occurs while creating the user`,
+                401: `returned if an anonymous (or unauthenticated) user tries to create a user`,
+                402: `returned if no more licenses available to create a user`,
+                403: `returned if user does not have enough permission to create a user`,
+                409: `returned if the user with the same userName already exists`,
+            },
+        });
+    }
+    /**
+     * Update user
+     * Updates the user identified by the username. The following fields can be updated: email, full name.
+     * "**Requirements**:
+     * - The fullName should not be blank
+     * - The fullName should not contain any forbidden characters (< or >)
+     * - The fullName should not be anonymous (in english or other system locale)
+     * - The email should not be blank
+     * - The email should be a valid email address
+     *
+     * @param username
+     * @param requestBody Details of the user to be updated
+     * @returns void
+     * @throws ApiError
+     */
+    public static updateUser(
+        username: string,
+        requestBody?: UserDetailsForUpdate,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/rest/api/admin/user/{username}',
+            path: {
+                'username': username,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `returned if any error occurs while updating the user`,
+                401: `returned if an anonymous (or unauthenticated) user tries to update a user`,
+                403: `returned if user does not have enough permission to update a user`,
+            },
+        });
+    }
+    /**
+     * Delete user
+     * Deletes the given User identified by username. This action is processed asynchronously.
+     * @param username the username identifying the given user
+     * @returns LongTaskSubmission Produces a HTTP Accept 202 response from some other resource pointing to this class's LongTaskStatus resource.
+     * @throws ApiError
+     */
+    public static delete1(
+        username: string,
+    ): CancelablePromise<LongTaskSubmission> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/rest/api/admin/user/{username}',
+            path: {
+                'username': username,
+            },
+            errors: {
+                401: `The calling user is not authenticated or does not have the <b>LICENSED</b> permission.`,
+                403: `The calling user does not have permission to perform this action.`,
+                404: `No User exists for the provided username.`,
+            },
+        });
+    }
+    /**
+     * Disable user
+     * Disables the given User identified by username. This method is idempotent i.e. if the user is already disabled then no action will be taken.
+     * @param username the username identifying the given user
+     * @returns void
+     * @throws ApiError
+     */
+    public static disable(
+        username: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/rest/api/admin/user/{username}/disable',
+            path: {
+                'username': username,
+            },
+            errors: {
+                401: `The calling user is not authenticated or does not have the <b>LICENSED</b> permission.`,
+                403: `The calling user does not have permission to perform this action.`,
+                404: `No User exists for the provided username.`,
+            },
+        });
+    }
+    /**
+     * Enable user
+     * Enables the given User identified by username. This method is idempotent i.e. if the user is already enabled then no action will be taken.
+     * @param username the username identifying the given user
+     * @returns void
+     * @throws ApiError
+     */
+    public static enable(
+        username: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/rest/api/admin/user/{username}/enable',
+            path: {
+                'username': username,
+            },
+            errors: {
+                401: `The calling user is not authenticated or does not have the <b>LICENSED</b> permission.`,
+                403: `The calling user does not have permission to perform this action.`,
+                404: `No User exists for the provided username.`,
+            },
+        });
+    }
+}
+
+

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

@@ -0,0 +1,67 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Person } from '../models/Person.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class AdminUsersService {
+    /**
+     * Get active users
+     * Gets a paginated collection of all active users (users which count into license usage).
+     * This will exclude users that are:
+     * - anonymous,
+     * - deactivated,
+     * - externally deleted,
+     * - shadowed
+     * - unlicensed
+     *
+     * This feature relies on search index and might not be accurate when site reindex is in progress.
+     *
+     * Example request URI(s):
+     * `http://example.com/confluence/rest/api/admin/users/list/active`
+     * `http://example.com/confluence/rest/api/admin/users/list/active?start=0`
+     * `http://example.com/confluence/rest/api/admin/users/list/active?start=0&limit=100`
+     * `http://example.com/confluence/rest/api/admin/users/list/active?start=0&limit=100&expand=status`
+     *
+     * @param expand properties to expand on the user.
+     * @param limit the limit of the number of users to return, this may be restricted by fixed system limits.
+     * @param start the start point of the collection to return. This must be non-negative. Default value is 0.
+     * @returns any returns a paginated collection of users.
+     * @throws ApiError
+     */
+    public static getActiveUsers(
+        expand?: string,
+        limit?: string,
+        start?: string,
+    ): CancelablePromise<{
+        results?: Array<Person>;
+        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/admin/users/list/active',
+            query: {
+                'expand': expand,
+                'limit': limit,
+                'start': start,
+            },
+            errors: {
+                403: `Returned if the calling user does not have permission to view users. This is possible for anonymous or un-licensed users.`,
+            },
+        });
+    }
+}
+
+

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.`,
+            },
+        });
+    }
+}
+
+