@atlassian-dc-mcp/jira 0.2.0 → 0.3.0

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

@@ -0,0 +1,49 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { SecuritySchemeJsonBean } from '../models/SecuritySchemeJsonBean.js';
+import type { SecuritySchemesJsonBean } from '../models/SecuritySchemesJsonBean.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class IssuesecurityschemesService {
+    /**
+     * Get all issue security schemes
+     * Returns all issue security schemes that are defined.
+     * @returns SecuritySchemesJsonBean Returns a list of all available issue security schemes.
+     * @throws ApiError
+     */
+    public static getIssueSecuritySchemes(): CancelablePromise<SecuritySchemesJsonBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/issuesecurityschemes',
+            errors: {
+                401: `Returned if the user is not logged in.`,
+                403: `Returned if the user does not have the administrator permission.`,
+            },
+        });
+    }
+    /**
+     * Get specific issue security scheme by id
+     * Returns the issue security scheme along with that are defined.
+     * @param id The issue security scheme id.
+     * @returns SecuritySchemeJsonBean Returns the issue security scheme with the given id.
+     * @throws ApiError
+     */
+    public static getIssueSecurityScheme(
+        id: string,
+    ): CancelablePromise<SecuritySchemeJsonBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/issuesecurityschemes/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Returned if the user is not logged in.`,
+                403: `Returned if the user does not have the administrator permission and the scheme is not used in any project where the user has administrative permission.`,
+            },
+        });
+    }
+}

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

@@ -0,0 +1,352 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AvatarBean } from '../models/AvatarBean.js';
+import type { AvatarCroppingBean } from '../models/AvatarCroppingBean.js';
+import type { EntityPropertiesKeysBean } from '../models/EntityPropertiesKeysBean.js';
+import type { EntityPropertyBean } from '../models/EntityPropertyBean.js';
+import type { FilePart } from '../models/FilePart.js';
+import type { IssueTypeCreateBean } from '../models/IssueTypeCreateBean.js';
+import type { IssueTypeJsonBean } from '../models/IssueTypeJsonBean.js';
+import type { IssueTypeUpdateBean } from '../models/IssueTypeUpdateBean.js';
+import type { PropertyBean } from '../models/PropertyBean.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class IssuetypeService {
+    /**
+     * Get list of all issue types visible to user
+     * Returns a list of all issue types visible to the user
+     * @returns IssueTypeJsonBean Returns a list of issue types.
+     * @throws ApiError
+     */
+    public static getIssueAllTypes(): CancelablePromise<IssueTypeJsonBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/issuetype',
+            errors: {
+                401: `Returned if the user is not logged in.`,
+                403: `Returned if the user does not have the administrator permission.`,
+            },
+        });
+    }
+    /**
+     * Create an issue type from JSON representation
+     * Creates an issue type from a JSON representation and adds the issue newly created issue type to the default issue type scheme.
+     * @param requestBody All information about the issue type.
+     * @returns any The new issue type has been created.
+     * @throws ApiError
+     */
+    public static createIssueType(
+        requestBody: IssueTypeCreateBean,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/2/issuetype',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if the request is invalid. This happens when the name is invalid or issue type is subtask on instance which has subtasks disabled.`,
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira.`,
+                409: `Returned if there already exists an issue type with the specified name.`,
+            },
+        });
+    }
+    /**
+     * Get paginated list of filtered issue types
+     * Returns paginated list of filtered issue types
+     * @param xRequestedWith
+     * @param maxResults
+     * @param query
+     * @param projectIds
+     * @param startAt
+     * @returns IssueTypeJsonBean Returns paginated list of issue types.
+     * @throws ApiError
+     */
+    public static getPaginatedIssueTypes(
+        xRequestedWith?: string,
+        maxResults: number = 100,
+        query: string = '',
+        projectIds?: Array<number>,
+        startAt?: number,
+    ): CancelablePromise<IssueTypeJsonBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/issuetype/page',
+            headers: {
+                'X-Requested-With': xRequestedWith,
+            },
+            query: {
+                'maxResults': maxResults,
+                'query': query,
+                'projectIds': projectIds,
+                'startAt': startAt,
+            },
+        });
+    }
+    /**
+     * Get full representation of issue type by id
+     * Returns a full representation of the issue type that has the given id.
+     * @param id The issue type id.
+     * @returns IssueTypeJsonBean Returns the issue type with the given id.
+     * @throws ApiError
+     */
+    public static getIssueType1(
+        id: string,
+    ): CancelablePromise<IssueTypeJsonBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/issuetype/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Returned if the issue type does not exist, or is not visible to the calling user.`,
+            },
+        });
+    }
+    /**
+     * Update specified issue type from JSON representation
+     * Updates the specified issue type from a JSON representation.
+     * @param id The issue type id.
+     * @param requestBody All information about the issue type.
+     * @returns any Returned if the issue type was updated successfully.
+     * @throws ApiError
+     */
+    public static updateIssueType(
+        id: string,
+        requestBody: IssueTypeUpdateBean,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/2/issuetype/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if the request is invalid. This happens when the name is invalid or if the avatar with given id does not exist.`,
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira.`,
+                404: `Returned if the issue type to update does not exist.`,
+                409: `Returned if there already exists an issue type with the specified name.`,
+            },
+        });
+    }
+    /**
+     * Delete specified issue type and migrate associated issues
+     * Deletes the specified issue type. If the issue type has any associated issues, these issues will be migrated to the alternative issue type specified in the parameter.
+     * @param id The issue type id.
+     * @param alternativeIssueTypeId The id of an issue type to which issues associated with the removed issue type will be migrated.
+     * @returns void
+     * @throws ApiError
+     */
+    public static deleteIssueType1(
+        id: string,
+        alternativeIssueTypeId: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/2/issuetype/{id}',
+            path: {
+                'id': id,
+                'alternativeIssueTypeId': alternativeIssueTypeId,
+            },
+            errors: {
+                400: `Returned if the request is invalid. It happens when there are associated issues with the issue type which is being removed, but it is impossible to migrate these issues to the alternative issue type.`,
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira.`,
+                404: `Returned if the issue type to update does not exist.`,
+            },
+        });
+    }
+    /**
+     * Get list of alternative issue types for given id
+     * Returns a list of all alternative issue types for the given issue type id.
+     * @param id The issue type id.
+     * @returns IssueTypeJsonBean Returns a list of issue types.
+     * @throws ApiError
+     */
+    public static getAlternativeIssueTypes(
+        id: string,
+    ): CancelablePromise<IssueTypeJsonBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/issuetype/{id}/alternatives',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Returned if the issue type does not exist, or is not visible to the calling user.`,
+            },
+        });
+    }
+    /**
+     * Convert temporary avatar into a real avatar
+     * Converts temporary avatar into a real avatar
+     * @param id The issue type id.
+     * @param requestBody Cropping instructions.
+     * @returns AvatarBean Returns created avatar.
+     * @throws ApiError
+     */
+    public static createAvatarFromTemporary1(
+        id: string,
+        requestBody: AvatarCroppingBean,
+    ): CancelablePromise<AvatarBean> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/2/issuetype/{id}/avatar',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if the cropping coordinates are invalid.`,
+                403: `Returned if the currently authenticated user does not have permission to pick avatar.`,
+                404: `Returned if the currently authenticated user does not have EDIT PROJECT permission.`,
+                500: `Returned if an error occurs while converting temporary avatar to real avatar.`,
+            },
+        });
+    }
+    /**
+     * Create temporary avatar using multipart for issue type
+     * Creates temporary avatar using multipart. The response is sent back as JSON stored in a textarea. This is because
+     * the client uses remote iframing to submit avatars using multipart. So we must send them a valid HTML page back from
+     * which the client parses the JSON from.
+     * Creating a temporary avatar is part of a 3-step process in uploading a new
+     * avatar for an issue type: upload, crop, confirm. This endpoint allows you to use a multipart upload
+     * instead of sending the image directly as the request body.
+     * You *must* use "avatar" as the name of the upload parameter:
+     * curl -c cookiejar.txt -X POST -u admin:admin -H "X-Atlassian-Token: no-check" \
+     * -F "avatar=@mynewavatar.png;type=image/png" \
+     * 'http://localhost:8090/jira/rest/api/2/issuetype/1/avatar/temporary'
+     * @param id The issue type id.
+     * @param formData
+     * @returns AvatarCroppingBean Temporary avatar cropping instructions embeded in HTML page. Error messages will also be embeded in the page.
+     * @throws ApiError
+     */
+    public static storeTemporaryAvatarUsingMultiPart(
+        id: string,
+        formData?: FilePart,
+    ): CancelablePromise<AvatarCroppingBean> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/2/issuetype/{id}/avatar/temporary',
+            path: {
+                'id': id,
+            },
+            formData: formData,
+            mediaType: 'multipart/form-data',
+            errors: {
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira.`,
+                404: `Returned if the issue type to update does not exist or if the request does not contain valid XSRF token.`,
+            },
+        });
+    }
+    /**
+     * Get all properties keys for issue type
+     * Returns the keys of all properties for the issue type identified by the id
+     * @param issueTypeId The issue type from which the keys will be returned.
+     * @returns EntityPropertiesKeysBean Returns keys of all properties for the issue type.
+     * @throws ApiError
+     */
+    public static getPropertyKeys(
+        issueTypeId: string,
+    ): CancelablePromise<EntityPropertiesKeysBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/issuetype/{issueTypeId}/properties',
+            path: {
+                'issueTypeId': issueTypeId,
+            },
+            errors: {
+                400: `Returned if the issue type id is invalid.`,
+                404: `Returned if the issue type with given id does not exist or if the user does not have permissions to view this issue type.`,
+            },
+        });
+    }
+    /**
+     * Get value of specified issue type's property
+     * Returns the value of the property with a given key from the issue type identified by the id
+     * @param propertyKey The key of the property to return.
+     * @param issueTypeId The issue type from which the property will be returned.
+     * @returns EntityPropertyBean Returns the value of the property with a given key from the issue type.
+     * @throws ApiError
+     */
+    public static getProperty4(
+        propertyKey: string,
+        issueTypeId: string,
+    ): CancelablePromise<EntityPropertyBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/issuetype/{issueTypeId}/properties/{propertyKey}',
+            path: {
+                'propertyKey': propertyKey,
+                'issueTypeId': issueTypeId,
+            },
+            errors: {
+                400: `Returned if the issue type id is invalid.`,
+                404: `Returned if the issue type with given id does not exist or if the property with given key is not found.`,
+            },
+        });
+    }
+    /**
+     * Update specified issue type's property
+     * Sets the value of the specified issue type's property
+     * @param propertyKey The key of the issue type's property. The maximum length of the key is 255 bytes
+     * @param issueTypeId The issue type on which the property will be set.
+     * @param requestBody The value of the issue type's property. The value has to be a valid, non-empty JSON conforming to http://tools.ietf.org/html/rfc4627. The maximum length of the property value is 32768 bytes.
+     * @returns any Returned if the issue type property is successfully updated.
+     * @throws ApiError
+     */
+    public static setProperty3(
+        propertyKey: string,
+        issueTypeId: string,
+        requestBody: PropertyBean,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/2/issuetype/{issueTypeId}/properties/{propertyKey}',
+            path: {
+                'propertyKey': propertyKey,
+                'issueTypeId': issueTypeId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if the issue type id is invalid.`,
+                404: `Returned if the issue type with given id does not exist or if the user does not have permissions to edit this issue type.`,
+            },
+        });
+    }
+    /**
+     * Delete specified issue type's property
+     * Removes the property from the issue type identified by the id
+     * @param propertyKey The key of the property to remove.
+     * @param issueTypeId The issue type from which the property will be removed.
+     * @returns void
+     * @throws ApiError
+     */
+    public static deleteProperty4(
+        propertyKey: string,
+        issueTypeId: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/2/issuetype/{issueTypeId}/properties/{propertyKey}',
+            path: {
+                'propertyKey': propertyKey,
+                'issueTypeId': issueTypeId,
+            },
+            errors: {
+                400: `Returned if the issue type id is invalid.`,
+                404: `Returned if the issue type with given id does not exist or if the property with given key is not found.`,
+            },
+        });
+    }
+}

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

@@ -0,0 +1,260 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AssociateProjectsBean } from '../models/AssociateProjectsBean.js';
+import type { IssueTypeSchemeBean } from '../models/IssueTypeSchemeBean.js';
+import type { IssueTypeSchemeCreateUpdateBean } from '../models/IssueTypeSchemeCreateUpdateBean.js';
+import type { IssueTypeSchemeListBean } from '../models/IssueTypeSchemeListBean.js';
+import type { ProjectBean } from '../models/ProjectBean.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class IssuetypeschemeService {
+    /**
+     * Get list of all issue type schemes visible to user
+     * Returns a list of all issue type schemes visible to the user. All issue types associated with the scheme will only be returned if an additional query parameter is provided: expand=schemes.issueTypes. Similarly, the default issue type associated with the scheme (if one exists) will only be returned if an additional query parameter is provided: expand=schemes.defaultIssueType. Note that both query parameters can be used together: expand=schemes.issueTypes,schemes.defaultIssueType.
+     * @returns IssueTypeSchemeListBean Returns a list of issue type schemes.
+     * @throws ApiError
+     */
+    public static getAllIssueTypeSchemes(): CancelablePromise<IssueTypeSchemeListBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/issuetypescheme',
+            errors: {
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira.`,
+            },
+        });
+    }
+    /**
+     * Create an issue type scheme from JSON representation
+     * Creates an issue type scheme from a JSON representation
+     * @param requestBody Issue type scheme creation details.
+     * @returns IssueTypeSchemeBean Returns a JSON representation of the newly created IssueTypeScheme if successful.
+     * @throws ApiError
+     */
+    public static createIssueTypeScheme(
+        requestBody: IssueTypeSchemeCreateUpdateBean,
+    ): CancelablePromise<IssueTypeSchemeBean> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/2/issuetypescheme',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if the request is invalid.`,
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira.`,
+            },
+        });
+    }
+    /**
+     * Get full representation of issue type scheme by id
+     * Returns a full representation of the issue type scheme that has the given id
+     * @param schemeId A String containing an issue type scheme's id.
+     * @returns IssueTypeSchemeBean Returns a full representation of the issue type scheme with the given id.
+     * @throws ApiError
+     */
+    public static getIssueTypeScheme(
+        schemeId: string,
+    ): CancelablePromise<IssueTypeSchemeBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/issuetypescheme/{schemeId}',
+            path: {
+                'schemeId': schemeId,
+            },
+            errors: {
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira.`,
+                404: `Returned if the issue type scheme does not exist.`,
+            },
+        });
+    }
+    /**
+     * Update specified issue type scheme from JSON representation
+     * Updates the specified issue type scheme from a JSON representation
+     * @param schemeId The id of the issue type scheme to update.
+     * @param requestBody Specifies the new set of attributes that the issue type scheme will take on.
+     * @returns IssueTypeSchemeBean Returns a JSON representation of the updated issue type scheme.
+     * @throws ApiError
+     */
+    public static updateIssueTypeScheme(
+        schemeId: string,
+        requestBody: IssueTypeSchemeCreateUpdateBean,
+    ): CancelablePromise<IssueTypeSchemeBean> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/2/issuetypescheme/{schemeId}',
+            path: {
+                'schemeId': schemeId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if the request is invalid. This happens when the name or issue types are invalid. It also occurs when the default issue type isn't found in the associated issue types collection.`,
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira.`,
+                404: `Returned if the issue type scheme to update does not exist.`,
+            },
+        });
+    }
+    /**
+     * Delete specified issue type scheme
+     * Deletes the specified issue type scheme. Any projects associated with this IssueTypeScheme will be automatically associated with the global default IssueTypeScheme.
+     * @param schemeId The id of the issue type scheme to remove.
+     * @returns void
+     * @throws ApiError
+     */
+    public static deleteIssueTypeScheme(
+        schemeId: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/2/issuetypescheme/{schemeId}',
+            path: {
+                'schemeId': schemeId,
+            },
+            errors: {
+                400: `Returned if the request is invalid. It happens when there are associated issues with the issue type which is being removed, but it is impossible to migrate these issues to the alternative issue type.`,
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira or if an attempt is made to delete the default IssueTypeScheme.`,
+                404: `Returned if the issue type scheme which is supposed to be removed does not exist.`,
+            },
+        });
+    }
+    /**
+     * Get all of the associated projects for specified scheme
+     * For the specified issue type scheme, returns all of the associated projects
+     * @param schemeId Id of the issue type scheme whose projects we're accessing
+     * @param expand
+     * @returns ProjectBean The collection of projects associated with this issue type scheme.
+     * @throws ApiError
+     */
+    public static getAssociatedProjects(
+        schemeId: string,
+        expand?: string,
+    ): CancelablePromise<ProjectBean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/2/issuetypescheme/{schemeId}/associations',
+            path: {
+                'schemeId': schemeId,
+            },
+            query: {
+                'expand': expand,
+            },
+            errors: {
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira.`,
+                404: `Returned if the specified issue type scheme does not exist.`,
+            },
+        });
+    }
+    /**
+     * Set project associations for scheme
+     * Associates the given projects with the specified issue type scheme
+     * @param schemeId The id of the issue type scheme whose project associations we're replacing.
+     * @param requestBody Collection of projects, specified by id or key, to associate with this issue type scheme
+     * @returns any Confirmation that the association was successful.
+     * @throws ApiError
+     */
+    public static setProjectAssociationsForScheme(
+        schemeId: string,
+        requestBody: AssociateProjectsBean,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/2/issuetypescheme/{schemeId}/associations',
+            path: {
+                'schemeId': schemeId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if the request is invalid. This occurs when the supplied project ids/keys are invalid. It also happens if performing the association would require an issue type migration for any of the newly associated projects.`,
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira.`,
+                404: `Returned if the issue type scheme to update does not exist.`,
+            },
+        });
+    }
+    /**
+     * Add project associations to scheme
+     * Adds additional projects to those already associated with the specified issue type scheme
+     * @param schemeId The id of the issue type scheme whose project associations we're adding to.
+     * @param requestBody Collection of projects, specified by id or key, to associate with this issue type scheme
+     * @returns any Confirmation that the association was successful.
+     * @throws ApiError
+     */
+    public static addProjectAssociationsToScheme(
+        schemeId: string,
+        requestBody: AssociateProjectsBean,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/2/issuetypescheme/{schemeId}/associations',
+            path: {
+                'schemeId': schemeId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Returned if the request is invalid. This occurs when the supplied project ids/keys are invalid. It also happens if performing the association would require an issue type migration for any of the projects.`,
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira.`,
+                404: `Returned if the issue type scheme to update does not exist.`,
+            },
+        });
+    }
+    /**
+     * Remove all project associations for specified scheme
+     * Removes all project associations for the specified issue type scheme
+     * @param schemeId The id of the issue type scheme whose project associations we're removing
+     * @returns void
+     * @throws ApiError
+     */
+    public static removeAllProjectAssociations(
+        schemeId: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/2/issuetypescheme/{schemeId}/associations',
+            path: {
+                'schemeId': schemeId,
+            },
+            errors: {
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira or if an attempt is made to remove associations for the default/global issue type scheme.`,
+                404: `Returned if the specified issue type scheme does not exist.`,
+            },
+        });
+    }
+    /**
+     * Remove given project association for specified scheme
+     * For the specified issue type scheme, removes the given project association
+     * @param projIdOrKey The id or key of the project that is to be un-associated with the issue type scheme
+     * @param schemeId The id of the issue type scheme whose project association we're removing
+     * @returns void
+     * @throws ApiError
+     */
+    public static removeProjectAssociation(
+        projIdOrKey: string,
+        schemeId: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/2/issuetypescheme/{schemeId}/associations/{projIdOrKey}',
+            path: {
+                'projIdOrKey': projIdOrKey,
+                'schemeId': schemeId,
+            },
+            errors: {
+                401: `Returned if the calling user is not authenticated.`,
+                403: `Returned if the calling user does not have permission to administer Jira or if an attempt is made to remove an association for the default/global issue type scheme.`,
+                404: `Returned if the specified issue type scheme or project does not exist.`,
+            },
+        });
+    }
+}