/* 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 {
    APIToken,
    APITokenFromJSON,
    APITokenToJSON,
    APITokenPartialUpdate,
    APITokenPartialUpdateFromJSON,
    APITokenPartialUpdateToJSON,
    APITokenUpdate,
    APITokenUpdateFromJSON,
    APITokenUpdateToJSON,
    APITokenWithSecret,
    APITokenWithSecretFromJSON,
    APITokenWithSecretToJSON,
    APITokenWithSecretUpdate,
    APITokenWithSecretUpdateFromJSON,
    APITokenWithSecretUpdateToJSON,
    AuthLoginEndpointRequest,
    AuthLoginEndpointRequestFromJSON,
    AuthLoginEndpointRequestToJSON,
    AuthLoginEndpointResponse,
    AuthLoginEndpointResponseFromJSON,
    AuthLoginEndpointResponseToJSON,
    ElementsUserDetail,
    ElementsUserDetailFromJSON,
    ElementsUserDetailToJSON,
    GeneratePasswordEndpointResponse,
    GeneratePasswordEndpointResponseFromJSON,
    GeneratePasswordEndpointResponseToJSON,
    ImpersonationEndpointRequest,
    ImpersonationEndpointRequestFromJSON,
    ImpersonationEndpointRequestToJSON,
    OneTimeAccessToken,
    OneTimeAccessTokenFromJSON,
    OneTimeAccessTokenToJSON,
    ParseSAMLIDPMetadataRequest,
    ParseSAMLIDPMetadataRequestFromJSON,
    ParseSAMLIDPMetadataRequestToJSON,
    ParsedSAMLIDPMetadata,
    ParsedSAMLIDPMetadataFromJSON,
    ParsedSAMLIDPMetadataToJSON,
    PasswordResetEndpointRequest,
    PasswordResetEndpointRequestFromJSON,
    PasswordResetEndpointRequestToJSON,
    SAMLProvider,
    SAMLProviderFromJSON,
    SAMLProviderToJSON,
    SAMLProviderPartialUpdate,
    SAMLProviderPartialUpdateFromJSON,
    SAMLProviderPartialUpdateToJSON,
    SAMLProviderUpdate,
    SAMLProviderUpdateFromJSON,
    SAMLProviderUpdateToJSON,
    SendLinkEmailRequest,
    SendLinkEmailRequestFromJSON,
    SendLinkEmailRequestToJSON,
    Ticket,
    TicketFromJSON,
    TicketToJSON,
} from '../models';

export interface CheckAuthTicketRequest {
    ticket: Ticket;
}

export interface CreateAPITokenRequest {
    aPITokenWithSecretUpdate: APITokenWithSecretUpdate;
}

export interface CreateSAMLProviderRequest {
    sAMLProviderUpdate: SAMLProviderUpdate;
}

export interface DeleteAPITokenRequest {
    id: number;
}

export interface DeleteAccessTokenRequest {
    id: number;
}

export interface DeleteSAMLProviderRequest {
    id: number;
}

export interface GetAPITokenRequest {
    id: number;
}

export interface GetAccessTokenRequest {
    id: number;
}

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

export interface GetAllAccessTokensRequest {
    sharedBundles?: string;
    sharedDirectories?: string;
    sharedBundlesAsset?: number;
    user?: number;
    createdBy?: number;
    ordering?: string;
    limit?: number;
    offset?: number;
}

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

export interface GetSAMLProviderRequest {
    id: number;
}

export interface GetSAMLServiceProviderMetadataRequest {
    id: number;
}

export interface LoginRequest {
    authLoginEndpointRequest: AuthLoginEndpointRequest;
}

export interface ParseSAMLIDPMetadataOperationRequest {
    parseSAMLIDPMetadataRequest: ParseSAMLIDPMetadataRequest;
}

export interface PatchAPITokenRequest {
    id: number;
    aPITokenPartialUpdate: APITokenPartialUpdate;
}

export interface PatchSAMLProviderRequest {
    id: number;
    sAMLProviderPartialUpdate: SAMLProviderPartialUpdate;
}

export interface ReceiveSAMLAuthAssertionRequest {
    id: number;
}

export interface RefreshSAMLIDPMetadataRequest {
    id: number;
    parseSAMLIDPMetadataRequest: ParseSAMLIDPMetadataRequest;
}

export interface ResetPasswordRequest {
    passwordResetEndpointRequest: PasswordResetEndpointRequest;
}

export interface ReturnFromSAMLAuthRequest {
    id: number;
}

export interface ReturnFromSAMLLogoutRequest {
    id: number;
}

export interface SendAccessTokenEmailNotificationRequest {
    id: number;
    sendLinkEmailRequest: SendLinkEmailRequest;
}

export interface StartImpersonationRequest {
    impersonationEndpointRequest: ImpersonationEndpointRequest;
}

export interface StartSAMLAuthRequest {
    id: number;
}

export interface StartSAMLLogoutRequest {
    id: number;
}

export interface UpdateAPITokenRequest {
    id: number;
    aPITokenUpdate: APITokenUpdate;
}

export interface UpdateSAMLProviderRequest {
    id: number;
    sAMLProviderUpdate: SAMLProviderUpdate;
}

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async checkAuthTicketRaw(requestParameters: CheckAuthTicketRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<ElementsUserDetail>> {
        if (requestParameters.ticket === null || requestParameters.ticket === undefined) {
            throw new runtime.RequiredError('ticket','Required parameter requestParameters.ticket was null or undefined when calling checkAuthTicket.');
        }

        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/auth/ticket/check`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: TicketToJSON(requestParameters.ticket),
        }, initOverrides);

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async checkAuthTicket(requestParameters: CheckAuthTicketRequest, initOverrides?: RequestInit): Promise<ElementsUserDetail> {
        const response = await this.checkAuthTicketRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createAPITokenRaw(requestParameters: CreateAPITokenRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<APITokenWithSecret>> {
        if (requestParameters.aPITokenWithSecretUpdate === null || requestParameters.aPITokenWithSecretUpdate === undefined) {
            throw new runtime.RequiredError('aPITokenWithSecretUpdate','Required parameter requestParameters.aPITokenWithSecretUpdate was null or undefined when calling createAPIToken.');
        }

        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/api-tokens`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: APITokenWithSecretUpdateToJSON(requestParameters.aPITokenWithSecretUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createAPIToken(requestParameters: CreateAPITokenRequest, initOverrides?: RequestInit): Promise<APITokenWithSecret> {
        const response = await this.createAPITokenRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createAuthTicketRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<Ticket>> {
        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/auth/ticket`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async createAuthTicket(initOverrides?: RequestInit): Promise<Ticket> {
        const response = await this.createAuthTicketRaw(initOverrides);
        return await response.value();
    }

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

        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/auth/saml`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SAMLProviderUpdateToJSON(requestParameters.sAMLProviderUpdate),
        }, initOverrides);

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

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deleteAPITokenRaw(requestParameters: DeleteAPITokenRequest, 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 deleteAPIToken.');
        }

        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/api-tokens/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deleteAPIToken(requestParameters: DeleteAPITokenRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteAPITokenRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deleteAccessTokenRaw(requestParameters: DeleteAccessTokenRequest, 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 deleteAccessToken.');
        }

        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/auth/access-tokens/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async deleteAccessToken(requestParameters: DeleteAccessTokenRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteAccessTokenRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async deleteSAMLProviderRaw(requestParameters: DeleteSAMLProviderRequest, 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 deleteSAMLProvider.');
        }

        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/auth/saml/{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 deleteSAMLProvider(requestParameters: DeleteSAMLProviderRequest, initOverrides?: RequestInit): Promise<void> {
        await this.deleteSAMLProviderRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async generatePasswordRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<GeneratePasswordEndpointResponse>> {
        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/auth/generate-password`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async generatePassword(initOverrides?: RequestInit): Promise<GeneratePasswordEndpointResponse> {
        const response = await this.generatePasswordRaw(initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAPITokenRaw(requestParameters: GetAPITokenRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<APIToken>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getAPIToken.');
        }

        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/api-tokens/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAPIToken(requestParameters: GetAPITokenRequest, initOverrides?: RequestInit): Promise<APIToken> {
        const response = await this.getAPITokenRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAccessTokenRaw(requestParameters: GetAccessTokenRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<OneTimeAccessToken>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getAccessToken.');
        }

        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/auth/access-tokens/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAccessToken(requestParameters: GetAccessTokenRequest, initOverrides?: RequestInit): Promise<OneTimeAccessToken> {
        const response = await this.getAccessTokenRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAllAPITokensRaw(requestParameters: GetAllAPITokensRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<APIToken>>> {
        const queryParameters: any = {};

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

        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/api-tokens`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAllAPITokens(requestParameters: GetAllAPITokensRequest, initOverrides?: RequestInit): Promise<Array<APIToken>> {
        const response = await this.getAllAPITokensRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAllAccessTokensRaw(requestParameters: GetAllAccessTokensRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<OneTimeAccessToken>>> {
        const queryParameters: any = {};

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

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

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

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

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

        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/auth/access-tokens`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async getAllAccessTokens(requestParameters: GetAllAccessTokensRequest, initOverrides?: RequestInit): Promise<Array<OneTimeAccessToken>> {
        const response = await this.getAllAccessTokensRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * User account permission: `None` (read) / `system:admin-access` (write) 
     */
    async getAllSAMLProvidersRaw(requestParameters: GetAllSAMLProvidersRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<Array<SAMLProvider>>> {
        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/auth/saml`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

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

        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/auth/saml/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     */
    async getSAMLServiceProviderMetadataRaw(requestParameters: GetSAMLServiceProviderMetadataRequest, 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 getSAMLServiceProviderMetadata.');
        }

        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/auth/saml/{id}/metadata`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async getSAMLServiceProviderMetadata(requestParameters: GetSAMLServiceProviderMetadataRequest, initOverrides?: RequestInit): Promise<void> {
        await this.getSAMLServiceProviderMetadataRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async loginRaw(requestParameters: LoginRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<AuthLoginEndpointResponse>> {
        if (requestParameters.authLoginEndpointRequest === null || requestParameters.authLoginEndpointRequest === undefined) {
            throw new runtime.RequiredError('authLoginEndpointRequest','Required parameter requestParameters.authLoginEndpointRequest was null or undefined when calling login.');
        }

        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/auth/login`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AuthLoginEndpointRequestToJSON(requestParameters.authLoginEndpointRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async login(requestParameters: LoginRequest, initOverrides?: RequestInit): Promise<AuthLoginEndpointResponse> {
        const response = await this.loginRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async logoutRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        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/auth/logout`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async logout(initOverrides?: RequestInit): Promise<void> {
        await this.logoutRaw(initOverrides);
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async logoutPageRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        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/auth/logout`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async logoutPage(initOverrides?: RequestInit): Promise<void> {
        await this.logoutPageRaw(initOverrides);
    }

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

        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/auth/saml/parse-idp-metadata`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ParseSAMLIDPMetadataRequestToJSON(requestParameters.parseSAMLIDPMetadataRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async parseSAMLIDPMetadata(requestParameters: ParseSAMLIDPMetadataOperationRequest, initOverrides?: RequestInit): Promise<ParsedSAMLIDPMetadata> {
        const response = await this.parseSAMLIDPMetadataRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async patchAPITokenRaw(requestParameters: PatchAPITokenRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<APIToken>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling patchAPIToken.');
        }

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

        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/api-tokens/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: APITokenPartialUpdateToJSON(requestParameters.aPITokenPartialUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async patchAPIToken(requestParameters: PatchAPITokenRequest, initOverrides?: RequestInit): Promise<APIToken> {
        const response = await this.patchAPITokenRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/auth/saml/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: SAMLProviderPartialUpdateToJSON(requestParameters.sAMLProviderPartialUpdate),
        }, initOverrides);

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

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

    /**
     */
    async receiveSAMLAuthAssertionRaw(requestParameters: ReceiveSAMLAuthAssertionRequest, 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 receiveSAMLAuthAssertion.');
        }

        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/auth/saml/{id}/assertion`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async receiveSAMLAuthAssertion(requestParameters: ReceiveSAMLAuthAssertionRequest, initOverrides?: RequestInit): Promise<void> {
        await this.receiveSAMLAuthAssertionRaw(requestParameters, initOverrides);
    }

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

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

        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/auth/saml/{id}/refresh-idp-metadata`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ParseSAMLIDPMetadataRequestToJSON(requestParameters.parseSAMLIDPMetadataRequest),
        }, initOverrides);

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

    /**
     * ### Required permissions    * User account permission: `system:admin-access` 
     */
    async refreshSAMLIDPMetadata(requestParameters: RefreshSAMLIDPMetadataRequest, initOverrides?: RequestInit): Promise<ParsedSAMLIDPMetadata> {
        const response = await this.refreshSAMLIDPMetadataRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async resetPasswordRaw(requestParameters: ResetPasswordRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.passwordResetEndpointRequest === null || requestParameters.passwordResetEndpointRequest === undefined) {
            throw new runtime.RequiredError('passwordResetEndpointRequest','Required parameter requestParameters.passwordResetEndpointRequest was null or undefined when calling resetPassword.');
        }

        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/auth/reset-password`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: PasswordResetEndpointRequestToJSON(requestParameters.passwordResetEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * <class \'rest_framework.permissions.AllowAny\'> 
     */
    async resetPassword(requestParameters: ResetPasswordRequest, initOverrides?: RequestInit): Promise<void> {
        await this.resetPasswordRaw(requestParameters, initOverrides);
    }

    /**
     */
    async returnFromSAMLAuthRaw(requestParameters: ReturnFromSAMLAuthRequest, 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 returnFromSAMLAuth.');
        }

        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/auth/saml/{id}/sso/return`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async returnFromSAMLAuth(requestParameters: ReturnFromSAMLAuthRequest, initOverrides?: RequestInit): Promise<void> {
        await this.returnFromSAMLAuthRaw(requestParameters, initOverrides);
    }

    /**
     */
    async returnFromSAMLLogoutRaw(requestParameters: ReturnFromSAMLLogoutRequest, 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 returnFromSAMLLogout.');
        }

        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/auth/saml/{id}/sls/return`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async returnFromSAMLLogout(requestParameters: ReturnFromSAMLLogoutRequest, initOverrides?: RequestInit): Promise<void> {
        await this.returnFromSAMLLogoutRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async sendAccessTokenEmailNotificationRaw(requestParameters: SendAccessTokenEmailNotificationRequest, 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 sendAccessTokenEmailNotification.');
        }

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

        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/auth/access-tokens/{id}/email`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SendLinkEmailRequestToJSON(requestParameters.sendLinkEmailRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async sendAccessTokenEmailNotification(requestParameters: SendAccessTokenEmailNotificationRequest, initOverrides?: RequestInit): Promise<void> {
        await this.sendAccessTokenEmailNotificationRaw(requestParameters, initOverrides);
    }

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

        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/auth/impersonation`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ImpersonationEndpointRequestToJSON(requestParameters.impersonationEndpointRequest),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

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

    /**
     */
    async startSAMLAuthRaw(requestParameters: StartSAMLAuthRequest, 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 startSAMLAuth.');
        }

        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/auth/saml/{id}/sso`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async startSAMLAuth(requestParameters: StartSAMLAuthRequest, initOverrides?: RequestInit): Promise<void> {
        await this.startSAMLAuthRaw(requestParameters, initOverrides);
    }

    /**
     */
    async startSAMLLogoutRaw(requestParameters: StartSAMLLogoutRequest, 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 startSAMLLogout.');
        }

        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/auth/saml/{id}/sls`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async startSAMLLogout(requestParameters: StartSAMLLogoutRequest, initOverrides?: RequestInit): Promise<void> {
        await this.startSAMLLogoutRaw(requestParameters, initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async stopImpersonationRaw(initOverrides?: RequestInit): Promise<runtime.ApiResponse<void>> {
        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/auth/impersonation/stop`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async stopImpersonation(initOverrides?: RequestInit): Promise<void> {
        await this.stopImpersonationRaw(initOverrides);
    }

    /**
     * ### Required permissions    * Authenticated user 
     */
    async updateAPITokenRaw(requestParameters: UpdateAPITokenRequest, initOverrides?: RequestInit): Promise<runtime.ApiResponse<APIToken>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateAPIToken.');
        }

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

        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/api-tokens/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: APITokenUpdateToJSON(requestParameters.aPITokenUpdate),
        }, initOverrides);

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

    /**
     * ### Required permissions    * Authenticated user 
     */
    async updateAPIToken(requestParameters: UpdateAPITokenRequest, initOverrides?: RequestInit): Promise<APIToken> {
        const response = await this.updateAPITokenRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        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/auth/saml/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SAMLProviderUpdateToJSON(requestParameters.sAMLProviderUpdate),
        }, initOverrides);

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

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

}