/* tslint:disable */
/* eslint-disable */
/**
 * ELEMENTS API
 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
 *
 * The version of the OpenAPI document: 2
 * 
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */


import * as runtime from '../runtime';
import {
    SlackChannel,
    SlackChannelFromJSON,
    SlackChannelToJSON,
    SlackConnection,
    SlackConnectionFromJSON,
    SlackConnectionToJSON,
    SlackConnectionPartialUpdate,
    SlackConnectionPartialUpdateFromJSON,
    SlackConnectionPartialUpdateToJSON,
    SlackConnectionUpdate,
    SlackConnectionUpdateFromJSON,
    SlackConnectionUpdateToJSON,
    SlackEmoji,
    SlackEmojiFromJSON,
    SlackEmojiToJSON,
    SlackMessage,
    SlackMessageFromJSON,
    SlackMessageToJSON,
    SlackUser,
    SlackUserFromJSON,
    SlackUserToJSON,
    TeamsConnection,
    TeamsConnectionFromJSON,
    TeamsConnectionToJSON,
    TeamsConnectionPartialUpdate,
    TeamsConnectionPartialUpdateFromJSON,
    TeamsConnectionPartialUpdateToJSON,
    TeamsConnectionUpdate,
    TeamsConnectionUpdateFromJSON,
    TeamsConnectionUpdateToJSON,
    TeamsMessage,
    TeamsMessageFromJSON,
    TeamsMessageToJSON,
    TeamsRecipient,
    TeamsRecipientFromJSON,
    TeamsRecipientToJSON,
} from '../models';

export interface DeleteSlackConnectionRequest {
    id: number;
}

export interface DeleteTeamsConnectionRequest {
    id: number;
}

export interface GetAllSlackConnectionsRequest {
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetAllTeamsConnectionsRequest {
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface GetSlackChannelsRequest {
    id: number;
}

export interface GetSlackConnectionRequest {
    id: number;
}

export interface GetSlackEmojiRequest {
    id: number;
}

export interface GetSlackUsersRequest {
    id: number;
}

export interface GetTeamsChannelsRequest {
    id: number;
}

export interface GetTeamsConnectionRequest {
    id: number;
}

export interface GetTeamsUsersRequest {
    id: number;
}

export interface PatchSlackConnectionRequest {
    id: number;
    slackConnectionPartialUpdate: SlackConnectionPartialUpdate;
}

export interface PatchTeamsConnectionRequest {
    id: number;
    teamsConnectionPartialUpdate: TeamsConnectionPartialUpdate;
}

export interface SendSlackMessageRequest {
    id: number;
    slackMessage: SlackMessage;
}

export interface SendTeamsMessageRequest {
    id: number;
    teamsMessage: TeamsMessage;
}

export interface StartSlackConnectionFlowRequest {
    ordering?: string;
    limit?: number;
    offset?: number;
}

export interface StartSlackConnectionTokenRefreshFlowRequest {
    id: number;
}

export interface StartTeamsConnectionFlowRequest {
    ordering?: string;
    limit?: number;
    offset?: number;
    team?: string;
}

export interface StartTeamsConnectionTokenRefreshFlowRequest {
    id: number;
    team?: string;
}

export interface UpdateSlackConnectionRequest {
    id: number;
    slackConnectionUpdate: SlackConnectionUpdate;
}

export interface UpdateTeamsConnectionRequest {
    id: number;
    teamsConnectionUpdate: TeamsConnectionUpdate;
}

/**
 * 
 */
export class IntegrationsApi extends runtime.BaseAPI {

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async deleteSlackConnectionRaw(requestParameters: DeleteSlackConnectionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteSlackConnection.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/slack/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async deleteSlackConnection(requestParameters: DeleteSlackConnectionRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteSlackConnectionRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async deleteTeamsConnectionRaw(requestParameters: DeleteTeamsConnectionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteTeamsConnection.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/teams/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async deleteTeamsConnection(requestParameters: DeleteTeamsConnectionRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteTeamsConnectionRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getAllSlackConnectionsRaw(requestParameters: GetAllSlackConnectionsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<SlackConnection>>> {
        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/slack`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SlackConnectionFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getAllSlackConnections(requestParameters: GetAllSlackConnectionsRequest, initOverrides?: RequestInit): Promise<Array<SlackConnection>> {
        const response = await this.getAllSlackConnectionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getAllTeamsConnectionsRaw(requestParameters: GetAllTeamsConnectionsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<TeamsConnection>>> {
        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/teams`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TeamsConnectionFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getAllTeamsConnections(requestParameters: GetAllTeamsConnectionsRequest, initOverrides?: RequestInit): Promise<Array<TeamsConnection>> {
        const response = await this.getAllTeamsConnectionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getSlackChannelsRaw(requestParameters: GetSlackChannelsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<SlackChannel>>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getSlackChannels.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/slack/{id}/channels`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SlackChannelFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getSlackChannels(requestParameters: GetSlackChannelsRequest, initOverrides?: RequestInit): Promise<Array<SlackChannel>> {
        const response = await this.getSlackChannelsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getSlackConnectionRaw(requestParameters: GetSlackConnectionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<SlackConnection>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getSlackConnection.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/slack/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SlackConnectionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getSlackConnection(requestParameters: GetSlackConnectionRequest, initOverrides?: RequestInit): Promise<SlackConnection> {
        const response = await this.getSlackConnectionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getSlackEmojiRaw(requestParameters: GetSlackEmojiRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<SlackEmoji>>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getSlackEmoji.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/slack/{id}/emoji`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SlackEmojiFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getSlackEmoji(requestParameters: GetSlackEmojiRequest, initOverrides?: RequestInit): Promise<Array<SlackEmoji>> {
        const response = await this.getSlackEmojiRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getSlackUsersRaw(requestParameters: GetSlackUsersRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<SlackUser>>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getSlackUsers.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/slack/{id}/users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SlackUserFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getSlackUsers(requestParameters: GetSlackUsersRequest, initOverrides?: RequestInit): Promise<Array<SlackUser>> {
        const response = await this.getSlackUsersRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getTeamsChannelsRaw(requestParameters: GetTeamsChannelsRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<TeamsRecipient>>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getTeamsChannels.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/teams/{id}/channels`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TeamsRecipientFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getTeamsChannels(requestParameters: GetTeamsChannelsRequest, initOverrides?: RequestInit): Promise<Array<TeamsRecipient>> {
        const response = await this.getTeamsChannelsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getTeamsConnectionRaw(requestParameters: GetTeamsConnectionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TeamsConnection>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getTeamsConnection.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/teams/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TeamsConnectionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getTeamsConnection(requestParameters: GetTeamsConnectionRequest, initOverrides?: RequestInit): Promise<TeamsConnection> {
        const response = await this.getTeamsConnectionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getTeamsUsersRaw(requestParameters: GetTeamsUsersRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<TeamsRecipient>>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getTeamsUsers.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/teams/{id}/users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TeamsRecipientFromJSON));
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async getTeamsUsers(requestParameters: GetTeamsUsersRequest, initOverrides?: RequestInit): Promise<Array<TeamsRecipient>> {
        const response = await this.getTeamsUsersRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async patchSlackConnectionRaw(requestParameters: PatchSlackConnectionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<SlackConnection>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchSlackConnection.');
        }

        if (requestParameters.slackConnectionPartialUpdate === null || requestParameters.slackConnectionPartialUpdate === undefined) {
            throw new runtime.RequiredError('slackConnectionPartialUpdate','Required parameter requestParameters.slackConnectionPartialUpdate was null or undefined when calling patchSlackConnection.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/slack/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: SlackConnectionPartialUpdateToJSON(requestParameters.slackConnectionPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SlackConnectionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async patchSlackConnection(requestParameters: PatchSlackConnectionRequest, initOverrides?: RequestInit): Promise<SlackConnection> {
        const response = await this.patchSlackConnectionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async patchTeamsConnectionRaw(requestParameters: PatchTeamsConnectionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TeamsConnection>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchTeamsConnection.');
        }

        if (requestParameters.teamsConnectionPartialUpdate === null || requestParameters.teamsConnectionPartialUpdate === undefined) {
            throw new runtime.RequiredError('teamsConnectionPartialUpdate','Required parameter requestParameters.teamsConnectionPartialUpdate was null or undefined when calling patchTeamsConnection.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/teams/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: TeamsConnectionPartialUpdateToJSON(requestParameters.teamsConnectionPartialUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TeamsConnectionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async patchTeamsConnection(requestParameters: PatchTeamsConnectionRequest, initOverrides?: RequestInit): Promise<TeamsConnection> {
        const response = await this.patchTeamsConnectionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async sendSlackMessageRaw(requestParameters: SendSlackMessageRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sendSlackMessage.');
        }

        if (requestParameters.slackMessage === null || requestParameters.slackMessage === undefined) {
            throw new runtime.RequiredError('slackMessage','Required parameter requestParameters.slackMessage was null or undefined when calling sendSlackMessage.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/slack/{id}/message`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SlackMessageToJSON(requestParameters.slackMessage),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async sendSlackMessage(requestParameters: SendSlackMessageRequest, initOverrides?: RequestInit): Promise<void> {
        await this.sendSlackMessageRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async sendTeamsMessageRaw(requestParameters: SendTeamsMessageRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sendTeamsMessage.');
        }

        if (requestParameters.teamsMessage === null || requestParameters.teamsMessage === undefined) {
            throw new runtime.RequiredError('teamsMessage','Required parameter requestParameters.teamsMessage was null or undefined when calling sendTeamsMessage.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/teams/{id}/send-message`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TeamsMessageToJSON(requestParameters.teamsMessage),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `tasks:manage` 
     */
    async sendTeamsMessage(requestParameters: SendTeamsMessageRequest, initOverrides?: RequestInit): Promise<void> {
        await this.sendTeamsMessageRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startSlackConnectionFlowRaw(requestParameters: StartSlackConnectionFlowRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/slack/connect`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startSlackConnectionFlow(requestParameters: StartSlackConnectionFlowRequest, initOverrides?: RequestInit): Promise<void> {
        await this.startSlackConnectionFlowRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startSlackConnectionTokenRefreshFlowRaw(requestParameters: StartSlackConnectionTokenRefreshFlowRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling startSlackConnectionTokenRefreshFlow.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/slack/{id}/refresh-token`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startSlackConnectionTokenRefreshFlow(requestParameters: StartSlackConnectionTokenRefreshFlowRequest, initOverrides?: RequestInit): Promise<void> {
        await this.startSlackConnectionTokenRefreshFlowRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startTeamsConnectionFlowRaw(requestParameters: StartTeamsConnectionFlowRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

        if (requestParameters.ordering !== undefined) {
            queryParameters['ordering'] = requestParameters.ordering;
        }

        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }

        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }

        if (requestParameters.team !== undefined) {
            queryParameters['team'] = requestParameters.team;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/teams/connect`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startTeamsConnectionFlow(requestParameters: StartTeamsConnectionFlowRequest, initOverrides?: RequestInit): Promise<void> {
        await this.startTeamsConnectionFlowRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startTeamsConnectionTokenRefreshFlowRaw(requestParameters: StartTeamsConnectionTokenRefreshFlowRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling startTeamsConnectionTokenRefreshFlow.');
        }

        const queryParameters: any = {};

        if (requestParameters.team !== undefined) {
            queryParameters['team'] = requestParameters.team;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/teams/{id}/refresh-token`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async startTeamsConnectionTokenRefreshFlow(requestParameters: StartTeamsConnectionTokenRefreshFlowRequest, initOverrides?: RequestInit): Promise<void> {
        await this.startTeamsConnectionTokenRefreshFlowRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async updateSlackConnectionRaw(requestParameters: UpdateSlackConnectionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<SlackConnection>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateSlackConnection.');
        }

        if (requestParameters.slackConnectionUpdate === null || requestParameters.slackConnectionUpdate === undefined) {
            throw new runtime.RequiredError('slackConnectionUpdate','Required parameter requestParameters.slackConnectionUpdate was null or undefined when calling updateSlackConnection.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/slack/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SlackConnectionUpdateToJSON(requestParameters.slackConnectionUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SlackConnectionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async updateSlackConnection(requestParameters: UpdateSlackConnectionRequest, initOverrides?: RequestInit): Promise<SlackConnection> {
        const response = await this.updateSlackConnectionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async updateTeamsConnectionRaw(requestParameters: UpdateTeamsConnectionRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<TeamsConnection>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateTeamsConnection.');
        }

        if (requestParameters.teamsConnectionUpdate === null || requestParameters.teamsConnectionUpdate === undefined) {
            throw new runtime.RequiredError('teamsConnectionUpdate','Required parameter requestParameters.teamsConnectionUpdate was null or undefined when calling updateTeamsConnection.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // Bearer authentication
        }

        const response = await this.request({
            path: `/api/2/integrations/teams/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: TeamsConnectionUpdateToJSON(requestParameters.teamsConnectionUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => TeamsConnectionFromJSON(jsonValue));
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async updateTeamsConnection(requestParameters: UpdateTeamsConnectionRequest, initOverrides?: RequestInit): Promise<TeamsConnection> {
        const response = await this.updateTeamsConnectionRaw(requestParameters, initOverrides);
        return await response.value();
    }

}