@atlassian-dc-mcp/confluence 0.1.3 → 0.2.0

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

@@ -0,0 +1,23 @@
+/* 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 AccessModeService {
+    /**
+     * Get access mode status
+     * Returns the access mode status for Confluence.
+     * @returns any Returns the access mode status for Confluence. Example: READ_WRITE
+     * @throws ApiError
+     */
+    public static getAccessModeStatus(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/rest/api/accessmode',
+        });
+    }
+}
+
+

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