@atlassian-dc-mcp/confluence 0.1.3 → 0.2.0

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

@@ -0,0 +1,56 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { User } from '../models/User.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class SpaceWatchersService {
+    /**
+     * Fetch users watching space
+     * Returns a paginated list of users watching the given Space identified by spaceKey. Only a Confluence Administrator or Space Administrator can perform this action.
+     * @param spaceKey the key of the Space the User is attempting to view.
+     * @param limit
+     * @param start
+     * @returns any returns a paginated list of users watching the given Space identified by spaceKey
+     * @throws ApiError
+     */
+    public static index4(
+        spaceKey: string,
+        limit: number = 25,
+        start?: number,
+    ): CancelablePromise<{
+        results?: Array<User>;
+        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/space/{spaceKey}/watchers',
+            path: {
+                'spaceKey': spaceKey,
+            },
+            query: {
+                'limit': limit,
+                'start': start,
+            },
+            errors: {
+                401: `The user is not authenticated or does not have the <b>LICENSED</b> permission.`,
+                403: `The user is not a Confluence Administrator or Space Administrator.`,
+                404: `The Space does not exist.`,
+            },
+        });
+    }
+}
+
+

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

@@ -0,0 +1,57 @@
+/* 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 UserGroupService {
+    /**
+     * Update user group
+     * Add the given User identified by username to the given Group identified by groupName.
+     *
+     * This method is idempotent i.e., if the membership already exists then no action will be taken.
+     * @param groupName The group name identifying the given group.
+     * @param username The username identifying the given user.
+     * @returns void
+     * @throws ApiError
+     */
+    public static update5(
+        groupName: string,
+        username: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/rest/api/user/{username}/group/{groupName}',
+            path: {
+                'groupName': groupName,
+                'username': username,
+            },
+        });
+    }
+    /**
+     * Delete user group
+     * Removes the given User identified by username from the given Group identified by groupName.
+     *
+     * This method is idempotent i.e., if the membership already exists then no action will be taken.
+     * @param groupName The group name identifying the given group.
+     * @param username The username identifying the given user.
+     * @returns void
+     * @throws ApiError
+     */
+    public static delete6(
+        groupName: string,
+        username: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/rest/api/user/{username}/group/{groupName}',
+            path: {
+                'groupName': groupName,
+                'username': username,
+            },
+        });
+    }
+}
+
+

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

@@ -0,0 +1,257 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { PasswordChangeDetails } from '../models/PasswordChangeDetails.js';
+import type { Person } from '../models/Person.js';
+import type { UserDetailsForUpdate } from '../models/UserDetailsForUpdate.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class UserService {
+    /**
+     * Change password
+     * Change the password for the current user.
+     *
+     * Validation Rules:
+     *
+     * - New password supplied cannot be null or blank
+     *
+     * Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user/current/password`
+     * @param requestBody password change details
+     * @returns void
+     * @throws ApiError
+     */
+    public static changePassword1(
+        requestBody?: PasswordChangeDetails,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/user/current/password',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: ` returned if any error occurs while changing user password. Refer the validation rules above.`,
+                401: `returned if the user is not authenticated.`,
+                403: `returned if current password is wrong or if the user has exceeded number of allowed failed login attempts
+                .`,
+            },
+        });
+    }
+    /**
+     * Get information about anonymous user type
+     * Get information about how anonymous is represented in Confluence. Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user/anonymous`
+     * @param expand properties to expand on the user.
+     * @returns Person Returns a full JSON representation of a user.
+     * @throws ApiError
+     */
+    public static getAnonymous(
+        expand?: string,
+    ): CancelablePromise<Person> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/user/anonymous',
+            query: {
+                'expand': expand,
+            },
+            errors: {
+                403: `Returned if the calling user does not have permission to use confluence.`,
+            },
+        });
+    }
+    /**
+     * Get current user
+     * Get information about the current logged in user. Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user/current`
+     * @param expand properties to expand on the user.
+     * @returns Person Returns a full JSON representation of a user.
+     * @throws ApiError
+     */
+    public static getCurrent(
+        expand?: string,
+    ): CancelablePromise<Person> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/user/current',
+            query: {
+                'expand': expand,
+            },
+            errors: {
+                403: `Returned if the calling user does not have permission to use confluence.`,
+            },
+        });
+    }
+    /**
+     * Update details of the current user
+     * Change the current user's details.
+     *
+     * Validation Rules:
+     * - Full name cannot be blank, containing <> characters or be reserved by Confluence.
+     * - Email must be a valid email address.
+     * - Current password must be supplied for changing email address.
+     *
+     * Example PUT request URI(s):
+     * `http://example.com/confluence/rest/api/user/current`
+     *
+     * @param requestBody User details
+     * @returns void
+     * @throws ApiError
+     */
+    public static updateUser1(
+        requestBody?: UserDetailsForUpdate,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/rest/api/user/current',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: ` Returned if any error occurs while updating user details. Refer the validation rules above.`,
+                401: `Returned if the user is not authenticated.`,
+                403: `Returned if current password is wrong or if the user has exceeded number of allowed failed login attempts
+                .`,
+            },
+        });
+    }
+    /**
+     * Get groups
+     * Get a paginated collection of groups that the given user is a member of. Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user/memberof?username=jblogs`
+     * `http://example.com/confluence/rest/api/user/memberof?key=402880824ff933a4014ff9345d7c0002`
+     * @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.
+     * @param key userkey of the user to request from this resource
+     * @param username userName of the user to get the groups for.
+     * @returns any Returns a full JSON representation of a user.
+     * @throws ApiError
+     */
+    public static getGroups1(
+        expand?: string,
+        limit?: string,
+        start?: string,
+        key?: string,
+        username?: 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/user/memberof',
+            query: {
+                'expand': expand,
+                'limit': limit,
+                'start': start,
+                'key': key,
+                'username': username,
+            },
+            errors: {
+                403: `Returned if the calling user does not have permission to use confluence.`,
+            },
+        });
+    }
+    /**
+     * Get user
+     * Get information about a user identified by either user key or username. Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user?username=jblogs`
+     * `http://example.com/confluence/rest/api/user?key=402880824ff933a4014ff9345d7c0002`
+     * @param expand properties to expand on the user.
+     * @param key userkey of the user to request from this resource.
+     * @param username userName of the user to create the new watcher for.
+     * @returns Person Returns a full JSON representation of a user
+     * @throws ApiError
+     */
+    public static getUser(
+        expand?: string,
+        key?: string,
+        username?: string,
+    ): CancelablePromise<Person> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/user',
+            query: {
+                'expand': expand,
+                'key': key,
+                'username': username,
+            },
+            errors: {
+                403: `Returned if the calling user does not have permission to view users.`,
+                404: `Returned if a user with the given username or userkey does not exist.`,
+            },
+        });
+    }
+    /**
+     * Get registered users
+     * Gets a paginated collection of all registered users, including but not limited to:
+     *
+     * - Disabled users
+     * - Enabled users
+     * - Enabled users which count towards the license count on the site
+     * - Enabled users which do not count towards the license count on the site
+     * - Enabled users which have "can use" global permissions
+     * - Enabled users which do not have "can use" global permissions
+     *
+     * Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user/list`
+     * `http://example.com/confluence/rest/api/user/list?start=0`
+     * `http://example.com/confluence/rest/api/user/list?start=0&limit=100`
+     * `http://example.com/confluence/rest/api/user/list?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 getUsers(
+        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/user/list',
+            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/UserWatchService.ts

@@ -0,0 +1,235 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ContentWatch } from '../models/ContentWatch.js';
+import type { SpaceWatch } from '../models/SpaceWatch.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class UserWatchService {
+    /**
+     * Get information about content watcher
+     * Get information about whether a user is watching a specified content. User is optional. If not specified, currently logged-in user will be used. Otherwise, it can be specified by either user key or username. When a user is specified and is different from the logged-in user, the logged-in user needs to be a Confluence administrator.
+     *
+     * Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user/watch/content/131213`
+     * `http://example.com/confluence/rest/api/user/watch/content/131213?username=jblogs`
+     * `http://example.com/confluence/rest/api/user/watch/content/131213?key=ff8080815a58e24c015a58e263710000`
+     * @param contentId id of the content.
+     * @param key userkey of the user to check for watching state.
+     * @param username username of the user to check for watching state.
+     * @returns any Returns a JSON representation containing the watching state.
+     * @throws ApiError
+     */
+    public static isWatchingContent(
+        contentId: string,
+        key?: string,
+        username?: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/user/watch/content/{contentId}',
+            path: {
+                'contentId': contentId,
+            },
+            query: {
+                'key': key,
+                'username': username,
+            },
+            errors: {
+                404: `Returned if no content exists for the specified content id or calling user does not have permission to perform the operation`,
+            },
+        });
+    }
+    /**
+     * Add content watcher
+     * Create a new watcher for the given user and content id. User is optional. If not specified, currently logged-in user will be used. Otherwise, it can be specified by either user key or username. When a user is specified and is different from the logged-in user, the logged-in user needs to be a Confluence administrator.
+     *
+     * Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user/watch/content/131213`
+     * `http://example.com/confluence/rest/api/user/watch/content/131213?username=jblogs`
+     * `http://example.com/confluence/rest/api/user/watch/content/131213?key=ff8080815a58e24c015a58e263710000`
+     * @param contentId id of the content.
+     * @param key userkey of the user to check for watching state.
+     * @param username username of the user to check for watching state.
+     * @returns ContentWatch Returned if the watcher was successfully created.
+     * @throws ApiError
+     */
+    public static addContentWatcher(
+        contentId: string,
+        key?: string,
+        username?: string,
+    ): CancelablePromise<ContentWatch> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/user/watch/content/{contentId}',
+            path: {
+                'contentId': contentId,
+            },
+            query: {
+                'key': key,
+                'username': username,
+            },
+            errors: {
+                404: `Returned if no content exists for the specified content id or the calling user does not have permission to perform the operation.`,
+            },
+        });
+    }
+    /**
+     * Remove content watcher
+     * Delete an existing watcher for the given user and content id. User is optional. If not specified, currently logged-in user will be used. Otherwise, it can be specified by either user key or username. When a user is specified and is different from the logged-in user, the logged-in user needs to be a Confluence administrator.
+     *
+     * Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user/watch/content/131213`
+     * `http://example.com/confluence/rest/api/user/watch/content/131213?username=jblogs`
+     * `http://example.com/confluence/rest/api/user/watch/content/131213?key=ff8080815a58e24c015a58e263710000`
+     * @param contentId id of the content.
+     * @param key userkey of the user to check for watching state.
+     * @param username username of the user to check for watching state.
+     * @returns void
+     * @throws ApiError
+     */
+    public static removeContentWatcher(
+        contentId: string,
+        key?: string,
+        username?: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/rest/api/user/watch/content/{contentId}',
+            path: {
+                'contentId': contentId,
+            },
+            query: {
+                'key': key,
+                'username': username,
+            },
+            errors: {
+                404: `Returned if no content exists for the specified content id or the calling user does not have permission to perform the operation`,
+            },
+        });
+    }
+    /**
+     * Get information about space watcher
+     * Get information about whether a user is watching a specified space. User is optional. If not specified, currently logged-in user will be used. Otherwise, it can be specified by either user key or username. When a user is specified and is different from the logged-in user, the logged-in user needs to be a Confluence administrator.
+     *
+     * Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY`
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY?username=jblogs`
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY?key=ff8080815a58e24c015a58e263710000`
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY?contentType=blostpost`
+     * @param spaceKey
+     * @param contentType an optional content type to check for watching state.
+     * @param key userkey of the user to check for watching state.
+     * @param username username of the user to check for watching state.
+     * @returns any Returns a JSON representation containing the watching state.
+     * @throws ApiError
+     */
+    public static isWatchingSpace(
+        spaceKey: string,
+        contentType?: string,
+        key?: string,
+        username?: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/user/watch/space/{spaceKey}',
+            path: {
+                'spaceKey': spaceKey,
+            },
+            query: {
+                'contentType': contentType,
+                'key': key,
+                'username': username,
+            },
+            errors: {
+                404: `Returned if no space exists for the specified space key or the calling user does not have permission to perform the operation.`,
+            },
+        });
+    }
+    /**
+     * Add space watcher
+     * Create a new watcher for the given user and space key. User is optional. If not specified, currently logged-in user will be used. Otherwise, it can be specified by either user key or username. When a user is specified and is different from the logged-in user, the logged-in user needs to be a Confluence administrator.
+     *
+     * Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY`
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY?username=jblogs`
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY?key=ff8080815a58e24c015a58e263710000`
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY?contentType=blogpost`
+     * @param spaceKey
+     * @param contentType the optional content type to delete the watcher for.
+     * @param key userKey of the user to create the new watcher for.
+     * @param username userName of the user to create the new watcher for.
+     * @returns SpaceWatch Returned if the watcher was successfully created
+     * @throws ApiError
+     */
+    public static addSpaceWatch(
+        spaceKey: string,
+        contentType?: string,
+        key?: string,
+        username?: string,
+    ): CancelablePromise<SpaceWatch> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/rest/api/user/watch/space/{spaceKey}',
+            path: {
+                'spaceKey': spaceKey,
+            },
+            query: {
+                'contentType': contentType,
+                'key': key,
+                'username': username,
+            },
+            errors: {
+                404: `Returned if no content exists for the specified space key or the calling user does not have permission to perform the operation`,
+            },
+        });
+    }
+    /**
+     * Remove space watcher
+     * Delete an existing watcher for the given user and space key. User is optional. If not specified, currently logged-in user will be used. Otherwise, it can be specified by either user key or username. When a user is specified and is different from the logged-in user, the logged-in user needs to be a Confluence administrator.
+     *
+     * Example request URI(s):
+     *
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY`
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY?username=jblogs`
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY?key=ff8080815a58e24c015a58e263710000`
+     * `http://example.com/confluence/rest/api/user/watch/space/SPACEKEY?contentType=blogpost`
+     * @param spaceKey
+     * @param contentType the optional content type to delete the watcher for.
+     * @param key userkey of the user to delete the watcher for.
+     * @param username username of the user to delete the watcher for.
+     * @returns void
+     * @throws ApiError
+     */
+    public static removeSpaceWatch(
+        spaceKey: string,
+        contentType?: string,
+        key?: string,
+        username?: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/rest/api/user/watch/space/{spaceKey}',
+            path: {
+                'spaceKey': spaceKey,
+            },
+            query: {
+                'contentType': contentType,
+                'key': key,
+                'username': username,
+            },
+            errors: {
+                404: `Returned if no content exists for the specified space key or the calling user does not have permission to perform the operation`,
+            },
+        });
+    }
+}
+
+