@atlassian-dc-mcp/jira 0.2.1 → 0.3.2

package/src/jira-client/services/FilterService.ts

@@ -0,0 +1,344 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ColumnLayout } from '../models/ColumnLayout.js';
+import type { DefaultShareScopeBean } from '../models/DefaultShareScopeBean.js';
+import type { FilterBean } from '../models/FilterBean.js';
+import type { FilterPermissionBean } from '../models/FilterPermissionBean.js';
+import type { SharePermissionInputBean } from '../models/SharePermissionInputBean.js';
+import type { StringList } from '../models/StringList.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class FilterService {
+    /**
+     * Create a new filter
+     * Creates a new filter, and returns newly created filter. Currently sets permissions just using the users default sharing permissions
+     * @param expand
+     * @param requestBody
+     * @returns FilterBean Returns a newly created filter
+     * @throws ApiError
+     */
+    public static createFilter(
+        expand?: StringList,
+        requestBody?: FilterBean,
+    ): CancelablePromise<FilterBean> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/2/filter',
+            query: {
+                'expand': expand,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if the input is invalid (e.g. filter name was not provided).`,
+            },
+        });
+    }
+    /**
+     * Get default share scope
+     * Returns the default share scope of the logged-in user
+     * @returns DefaultShareScopeBean Returns the default share scope of the logged-in user
+     * @throws ApiError
+     */
+    public static getDefaultShareScope(): CancelablePromise<DefaultShareScopeBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/filter/defaultShareScope',
+            errors: {
+                400: `Returned if there is a problem looking up preferences for the logged-in user`,
+            },
+        });
+    }
+    /**
+     * Set default share scope
+     * Sets the default share scope of the logged-in user. Available values are: AUTHENTICATED (for sharing with all logged-in users) and PRIVATE (for no shares).
+     * @param requestBody
+     * @returns DefaultShareScopeBean Returns the new default share scope of the logged-in user
+     * @throws ApiError
+     */
+    public static setDefaultShareScope(
+        requestBody?: DefaultShareScopeBean,
+    ): CancelablePromise<DefaultShareScopeBean> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/2/filter/defaultShareScope',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if there is a problem setting the preferences for the logged-in user`,
+            },
+        });
+    }
+    /**
+     * Get favourite filters
+     * Returns the favourite filters of the logged-in user
+     * @param expand
+     * @returns FilterBean Returns a list of favourite filters
+     * @throws ApiError
+     */
+    public static getFavouriteFilters(
+        expand?: StringList,
+    ): CancelablePromise<FilterBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/filter/favourite',
+            query: {
+                'expand': expand,
+            },
+            errors: {
+                401: `Returned if user is not logged-in and don't have access to any project`,
+            },
+        });
+    }
+    /**
+     * Get a filter by ID
+     * Returns a filter given an id
+     * @param id The filter id.
+     * @param expand
+     * @returns FilterBean Returns a filter
+     * @throws ApiError
+     */
+    public static getFilter(
+        id: string,
+        expand?: StringList,
+    ): CancelablePromise<FilterBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/filter/{id}',
+            path: {
+                'id': id,
+            },
+            query: {
+                'expand': expand,
+            },
+            errors: {
+                401: `Returned if user is not logged-in and don't have access to any project`,
+            },
+        });
+    }
+    /**
+     * Update an existing filter
+     * Updates an existing filter, and returns its new value. The following properties of a filter can be updated: 'jql', 'name', 'description'. Additionally, administrators can also update the 'owner' field. To get, set or unset 'favourite', use rest/api/1.0/filters/{id}/favourite with GET, PUT and DELETE methods instead.
+     * @param id The filter id.
+     * @param expand
+     * @param requestBody
+     * @returns FilterBean Returns the updated filter
+     * @throws ApiError
+     */
+    public static editFilter(
+        id: string,
+        expand?: StringList,
+        requestBody?: FilterBean,
+    ): CancelablePromise<FilterBean> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/2/filter/{id}',
+            path: {
+                'id': id,
+            },
+            query: {
+                'expand': expand,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if the input is invalid (e.g. filter name was not provided).`,
+            },
+        });
+    }
+    /**
+     * Delete a filter
+     * Delete a filter
+     * @param id The ID of the filter to delete.
+     * @returns void
+     * @throws ApiError
+     */
+    public static deleteFilter(
+        id: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/2/filter/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                400: `Returned if an error occurs.`,
+                401: `Returned if the calling user is not authenticated.`,
+            },
+        });
+    }
+    /**
+     * Get default columns for filter
+     * Returns the default columns for the given filter. Currently logged in user will be used as the user making such request.
+     * @param id The filter id.
+     * @returns ColumnLayout Returns a list of columns for configured for the given user
+     * @throws ApiError
+     */
+    public static defaultColumns1(
+        id: string,
+    ): CancelablePromise<ColumnLayout> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/filter/{id}/columns',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Returned if the filter does not have any columns.`,
+                500: `Returned if an error occurs while retrieving the column configuration.`,
+            },
+        });
+    }
+    /**
+     * Set default columns for filter
+     * Sets the default columns for the given filter
+     * @param id The filter id.
+     * @param requestBody
+     * @returns any Returned when the columns are saved successfully
+     * @throws ApiError
+     */
+    public static setColumns1(
+        id: string,
+        requestBody?: {
+            columns?: Array<string>;
+        },
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/2/filter/{id}/columns',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: '*/*',
+            errors: {
+                500: `Returned if an error occurs while retrieving the column configuration.`,
+            },
+        });
+    }
+    /**
+     * Reset columns for filter
+     * Resets the columns for the given filter such that the filter no longer has its own column config
+     * @param id The filter id.
+     * @returns void
+     * @throws ApiError
+     */
+    public static resetColumns1(
+        id: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/2/filter/{id}/columns',
+            path: {
+                'id': id,
+            },
+            errors: {
+                500: `Returned if an error occurs while retrieving the column configuration.`,
+            },
+        });
+    }
+    /**
+     * Get all share permissions of filter
+     * Returns all share permissions of the given filter
+     * @param id The filter id.
+     * @returns FilterPermissionBean Returns a list of share permissions associated with the given filter
+     * @throws ApiError
+     */
+    public static getSharePermissions(
+        id: string,
+    ): CancelablePromise<FilterPermissionBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/filter/{id}/permission',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Returned if user is not logged in.`,
+                404: `Returned when filter with given id does not exist or when the user does not have permissions to view the filter.`,
+            },
+        });
+    }
+    /**
+     * Add share permissions to filter
+     * Adds a share permissions to the given filter. Adding a global permission removes all previous permissions from the filter
+     * @param id The filter id.
+     * @param requestBody
+     * @returns FilterPermissionBean Returns share permissions associated with the given filter
+     * @throws ApiError
+     */
+    public static addSharePermission(
+        id: string,
+        requestBody?: SharePermissionInputBean,
+    ): CancelablePromise<FilterPermissionBean> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/2/filter/{id}/permission',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned given permission input bean is invalid or when user does not have the permission to share filters or when the user cannot edit the given filter.`,
+                401: `Returned if user is not logged in.`,
+                404: `Returned when filter with given id does not exist or when the user does not have permissions to view the filter.`,
+            },
+        });
+    }
+    /**
+     * Remove share permissions from filter
+     * Removes a share permissions from the given filter
+     * @param permissionId The permission id.
+     * @param id The filter id.
+     * @param permissionId
+     * @returns void
+     * @throws ApiError
+     */
+    public static deleteSharePermission(
+        permissionId: string,
+        id: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/2/filter/{id}/permission/{permission-id}',
+            path: {
+                'permissionId': permissionId,
+                'id': id,
+                'permission-id': permissionId,
+            },
+            errors: {
+                404: `Returned when filter or permission with given id does not exist or when the user does not have permissions to view the filter.`,
+            },
+        });
+    }
+    /**
+     * Get a single share permission of filter
+     * Returns a single share permission of the given filter
+     * @param permissionId The permission id.
+     * @param id The filter id.
+     * @returns FilterPermissionBean Returns a share permission associated with the given filter and permission-id
+     * @throws ApiError
+     */
+    public static getSharePermission(
+        permissionId: string,
+        id: string,
+    ): CancelablePromise<FilterPermissionBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/filter/{id}/permission/{permissionId}',
+            path: {
+                'permissionId': permissionId,
+                'id': id,
+            },
+            errors: {
+                401: `Returned if user is not logged in.`,
+                404: `Returned when filter or permission with given id does not exist or when the user does not have permissions to view the filter.`,
+            },
+        });
+    }
+}

package/src/jira-client/services/GroupService.ts

@@ -0,0 +1,150 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AddGroupBean } from '../models/AddGroupBean.js';
+import type { GroupBean } from '../models/GroupBean.js';
+import type { UpdateUserToGroupBean } from '../models/UpdateUserToGroupBean.js';
+import type { UserJsonBean } from '../models/UserJsonBean.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class GroupService {
+    /**
+     * Create a group with given parameters
+     * Creates a group by given group parameter
+     * @param requestBody
+     * @returns GroupBean Returns full representation of a Jira group in JSON format.
+     * @throws ApiError
+     */
+    public static createGroup(
+        requestBody?: AddGroupBean,
+    ): CancelablePromise<GroupBean> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/2/group',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if user requested an empty group name or group already exists`,
+                401: `Returned if the current user is not authenticated.`,
+                403: `Returned if the current user does not have administrator permissions.`,
+            },
+        });
+    }
+    /**
+     * Delete a specified group
+     * Deletes a group by given group parameter
+     * @param groupname The name of the group to delete.
+     * @param swapGroup A different group to transfer the restrictions to.
+     * @returns any Returned if the group was deleted.
+     * @throws ApiError
+     */
+    public static removeGroup(
+        groupname: string,
+        swapGroup?: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/2/group',
+            query: {
+                'groupname': groupname,
+                'swapGroup': swapGroup,
+            },
+            errors: {
+                400: `Returned if user requested a group that does not exist`,
+                401: `Returned if the current user is not authenticated.`,
+                403: `Returned if the current user does not have administrator permissions.`,
+                404: `Returned if the requested group was not found.`,
+            },
+        });
+    }
+    /**
+     * Get users from a specified group
+     * Returns a paginated list of users who are members of the specified group and its subgroups
+     * @param groupname The group name.
+     * @param includeInactiveUsers Include inactive users.
+     * @param maxResults The maximum number of users to return.
+     * @param startAt The index of the first user in group to return.
+     * @returns UserJsonBean Returns a paginated list of users in the group
+     * @throws ApiError
+     */
+    public static getUsersFromGroup(
+        groupname: string,
+        includeInactiveUsers?: string,
+        maxResults?: string,
+        startAt?: string,
+    ): CancelablePromise<UserJsonBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/group/member',
+            query: {
+                'includeInactiveUsers': includeInactiveUsers,
+                'maxResults': maxResults,
+                'groupname': groupname,
+                'startAt': startAt,
+            },
+            errors: {
+                400: `Returned if the name of the provided group is empty`,
+                401: `Returned if the user is not logged in.`,
+                403: `Returned if the calling user is not admin or sysadmin`,
+                404: `Returned if the specified group does not exist`,
+            },
+        });
+    }
+    /**
+     * Add a user to a specified group
+     * Adds given user to a group
+     * @param groupname A name of requested group.
+     * @param requestBody
+     * @returns GroupBean Returns full representation of a Jira group in JSON format.
+     * @throws ApiError
+     */
+    public static addUserToGroup(
+        groupname: string,
+        requestBody?: UpdateUserToGroupBean,
+    ): CancelablePromise<GroupBean> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/2/group/user',
+            query: {
+                'groupname': groupname,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if user requested an empty group name or the user already belongs to the group.`,
+                401: `Returned if the current user is not authenticated.`,
+                403: `Returned if the current user does not have administrator permissions.`,
+                404: `Returned if the requested group was not found or requested user was not found.`,
+            },
+        });
+    }
+    /**
+     * Remove a user from a specified group
+     * Removes given user from a group
+     * @param groupname A name of requested group.
+     * @param username User to remove from a group
+     * @returns any If the user was removed from the group.
+     * @throws ApiError
+     */
+    public static removeUserFromGroup(
+        groupname: string,
+        username: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/2/group/user',
+            query: {
+                'groupname': groupname,
+                'username': username,
+            },
+            errors: {
+                400: `Returned if user requested an empty group name`,
+                401: `Returned if the current user is not authenticated.`,
+                403: `Returned if the current user does not have administrator permissions.`,
+                404: `Returned if the requested group was not found or the requested user wan not found`,
+            },
+        });
+    }
+}

package/src/jira-client/services/GroupsService.ts

@@ -0,0 +1,37 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { GroupSuggestionsBean } from '../models/GroupSuggestionsBean.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class GroupsService {
+    /**
+     * Get groups matching a query
+     * Returns groups with substrings matching a given query
+     * @param maxResults Maximum number of results to return
+     * @param query A String to match groups against
+     * @param exclude List of groups to exclude
+     * @param userName Username for the context
+     * @returns GroupSuggestionsBean Returns a collection of matching groups
+     * @throws ApiError
+     */
+    public static findGroups(
+        maxResults?: string,
+        query?: string,
+        exclude?: string,
+        userName?: string,
+    ): CancelablePromise<GroupSuggestionsBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/groups/picker',
+            query: {
+                'maxResults': maxResults,
+                'query': query,
+                'exclude': exclude,
+                'userName': userName,
+            },
+        });
+    }
+}

package/src/jira-client/services/GroupuserpickerService.ts

@@ -0,0 +1,46 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { UsersAndGroupsBean } from '../models/UsersAndGroupsBean.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class GroupuserpickerService {
+    /**
+     * Get users and groups matching query with highlighting
+     * Returns a list of users and groups matching query with highlighting
+     * @param issueTypeId The list of issue type ids to further restrict the search
+     * @param maxResults The maximum number of users to return
+     * @param query A string used to search username, Name or e-mail address
+     * @param showAvatar Show avatar
+     * @param projectId The list of project ids to further restrict the search
+     * @param fieldId The custom field id
+     * @returns UsersAndGroupsBean Returns a list of users and groups matching query with highlighting
+     * @throws ApiError
+     */
+    public static findUsersAndGroups(
+        issueTypeId?: string,
+        maxResults?: string,
+        query?: string,
+        showAvatar?: string,
+        projectId?: string,
+        fieldId?: string,
+    ): CancelablePromise<UsersAndGroupsBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/groupuserpicker',
+            query: {
+                'issueTypeId': issueTypeId,
+                'maxResults': maxResults,
+                'query': query,
+                'showAvatar': showAvatar,
+                'projectId': projectId,
+                'fieldId': fieldId,
+            },
+            errors: {
+                403: `Returned if the user does not have permission to view users and groups`,
+            },
+        });
+    }
+}

package/src/jira-client/services/IndexService.ts

@@ -0,0 +1,45 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { IndexSummaryBean } from '../models/IndexSummaryBean.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class IndexService {
+    /**
+     * Get index condition summary
+     * Returns a summary of the index condition of the current node.
+     * The returned data consists of:
+     * - `nodeId` - Node identifier.
+     * - `reportTime` - Time of this report creation.
+     * - `issueIndex` - Summary of the issue index status.
+     * - `replicationQueues` - Map of index replication queues, where keys represent nodes from which replication operations came from.
+     *
+     * `issueIndex` can contain:
+     * - `indexReadable` - If `false` the endpoint failed to read data from the issue index (check Jira logs for detailed stack trace), otherwise `true`.
+     * - `countInDatabase` - Count of issues found in the database.
+     * - `countInIndex` - Count of issues found while querying the index.
+     * - `lastUpdatedInDatabase` - Time of the last update of the issue found in the database.
+     * - `lastUpdatedInIndex` - Time of the last update of the issue found while querying the index.
+     * `replicationQueues`'s map values can contain:
+     * - `lastConsumedOperation` - Last executed index replication operation by the current node from the sending node's queue.
+     * - `lastConsumedOperation.id` - Identifier of the operation.
+     * - `lastConsumedOperation.replicationTime` - Time when the operation was sent to other nodes.
+     * - `lastOperationInQueue` - Last index replication operation in the sending node's queue.
+     * - `lastOperationInQueue.id` - Identifier of the operation.
+     * - `lastOperationInQueue.replicationTime` - Time when the operation was sent to other nodes.
+     * - `queueSize` - Number of operations in the queue from the sending node to the current node.
+     * @returns IndexSummaryBean Returns an object with data about the condition of the Jira node's index
+     * @throws ApiError
+     */
+    public static getIndexSummary(): CancelablePromise<IndexSummaryBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/index/summary',
+            errors: {
+                403: `Returned when the current authenticated user does not have admin permission`,
+            },
+        });
+    }
+}

package/src/jira-client/services/IndexSnapshotService.ts

@@ -0,0 +1,58 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { IndexSnapshotBean } from '../models/IndexSnapshotBean.js';
+import type { IndexSnapshotPromiseBean } from '../models/IndexSnapshotPromiseBean.js';
+import type { IndexSnapshotStatusBean } from '../models/IndexSnapshotStatusBean.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class IndexSnapshotService {
+    /**
+     * Get list of available index snapshots
+     * Lists available index snapshots absolute paths with timestamps
+     * @returns IndexSnapshotBean Returns the list consisting of absolute paths to currently available index snapshots
+     * @throws ApiError
+     */
+    public static listIndexSnapshot(): CancelablePromise<IndexSnapshotBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/index-snapshot',
+            errors: {
+                401: `Returned if the caller doesn't have sufficient privileges`,
+            },
+        });
+    }
+    /**
+     * Create index snapshot if not in progress
+     * Starts taking an index snapshot if no other snapshot creation process is in progress
+     * @returns IndexSnapshotPromiseBean Returns the absolute path which index snapshot will be placed in, after it's created
+     * @throws ApiError
+     */
+    public static createIndexSnapshot(): CancelablePromise<IndexSnapshotPromiseBean> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/2/index-snapshot',
+            errors: {
+                401: `Returned if the caller doesn't have sufficient privileges`,
+                409: `Returned if snapshot creation is already in progress`,
+            },
+        });
+    }
+    /**
+     * Get index snapshot creation status
+     * Checks if index snapshot creation is currently running
+     * @returns IndexSnapshotStatusBean Returns status of current snapshot creation
+     * @throws ApiError
+     */
+    public static isIndexSnapshotRunning(): CancelablePromise<IndexSnapshotStatusBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/index-snapshot/isRunning',
+            errors: {
+                401: `Returned if the caller doesn't have sufficient privileges`,
+            },
+        });
+    }
+}