/* tslint:disable */
/* eslint-disable */
/**
 * authentik
 * Making authentication simple.
 *
 * The version of the OpenAPI document: 2026.2.3-rc1
 * Contact: hello@goauthentik.io
 *
 * 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 type {
  AgentAuthenticationResponse,
  AgentConfig,
  AgentConnector,
  AgentConnectorRequest,
  AgentPSSODeviceRegistrationRequest,
  AgentPSSODeviceRegistrationResponse,
  AgentPSSOUserRegistrationRequest,
  AgentTokenResponse,
  Connector,
  DeviceAccessGroup,
  DeviceAccessGroupRequest,
  DeviceFactsRequest,
  DeviceSummary,
  DeviceUserBinding,
  DeviceUserBindingRequest,
  EndpointDevice,
  EndpointDeviceDetails,
  EndpointDeviceRequest,
  EnrollRequest,
  EnrollmentToken,
  EnrollmentTokenRequest,
  FleetConnector,
  FleetConnectorRequest,
  GenericError,
  MDMConfigRequest,
  MDMConfigResponse,
  PaginatedAgentConnectorList,
  PaginatedConnectorList,
  PaginatedDeviceAccessGroupList,
  PaginatedDeviceUserBindingList,
  PaginatedEndpointDeviceList,
  PaginatedEnrollmentTokenList,
  PaginatedFleetConnectorList,
  PatchedAgentConnectorRequest,
  PatchedDeviceAccessGroupRequest,
  PatchedDeviceUserBindingRequest,
  PatchedEndpointDeviceRequest,
  PatchedEnrollmentTokenRequest,
  PatchedFleetConnectorRequest,
  TokenView,
  TypeCreate,
  UsedBy,
  UserSelf,
  ValidationError,
} from '../models/index';
import {
    AgentAuthenticationResponseFromJSON,
    AgentAuthenticationResponseToJSON,
    AgentConfigFromJSON,
    AgentConfigToJSON,
    AgentConnectorFromJSON,
    AgentConnectorToJSON,
    AgentConnectorRequestFromJSON,
    AgentConnectorRequestToJSON,
    AgentPSSODeviceRegistrationRequestFromJSON,
    AgentPSSODeviceRegistrationRequestToJSON,
    AgentPSSODeviceRegistrationResponseFromJSON,
    AgentPSSODeviceRegistrationResponseToJSON,
    AgentPSSOUserRegistrationRequestFromJSON,
    AgentPSSOUserRegistrationRequestToJSON,
    AgentTokenResponseFromJSON,
    AgentTokenResponseToJSON,
    ConnectorFromJSON,
    ConnectorToJSON,
    DeviceAccessGroupFromJSON,
    DeviceAccessGroupToJSON,
    DeviceAccessGroupRequestFromJSON,
    DeviceAccessGroupRequestToJSON,
    DeviceFactsRequestFromJSON,
    DeviceFactsRequestToJSON,
    DeviceSummaryFromJSON,
    DeviceSummaryToJSON,
    DeviceUserBindingFromJSON,
    DeviceUserBindingToJSON,
    DeviceUserBindingRequestFromJSON,
    DeviceUserBindingRequestToJSON,
    EndpointDeviceFromJSON,
    EndpointDeviceToJSON,
    EndpointDeviceDetailsFromJSON,
    EndpointDeviceDetailsToJSON,
    EndpointDeviceRequestFromJSON,
    EndpointDeviceRequestToJSON,
    EnrollRequestFromJSON,
    EnrollRequestToJSON,
    EnrollmentTokenFromJSON,
    EnrollmentTokenToJSON,
    EnrollmentTokenRequestFromJSON,
    EnrollmentTokenRequestToJSON,
    FleetConnectorFromJSON,
    FleetConnectorToJSON,
    FleetConnectorRequestFromJSON,
    FleetConnectorRequestToJSON,
    GenericErrorFromJSON,
    GenericErrorToJSON,
    MDMConfigRequestFromJSON,
    MDMConfigRequestToJSON,
    MDMConfigResponseFromJSON,
    MDMConfigResponseToJSON,
    PaginatedAgentConnectorListFromJSON,
    PaginatedAgentConnectorListToJSON,
    PaginatedConnectorListFromJSON,
    PaginatedConnectorListToJSON,
    PaginatedDeviceAccessGroupListFromJSON,
    PaginatedDeviceAccessGroupListToJSON,
    PaginatedDeviceUserBindingListFromJSON,
    PaginatedDeviceUserBindingListToJSON,
    PaginatedEndpointDeviceListFromJSON,
    PaginatedEndpointDeviceListToJSON,
    PaginatedEnrollmentTokenListFromJSON,
    PaginatedEnrollmentTokenListToJSON,
    PaginatedFleetConnectorListFromJSON,
    PaginatedFleetConnectorListToJSON,
    PatchedAgentConnectorRequestFromJSON,
    PatchedAgentConnectorRequestToJSON,
    PatchedDeviceAccessGroupRequestFromJSON,
    PatchedDeviceAccessGroupRequestToJSON,
    PatchedDeviceUserBindingRequestFromJSON,
    PatchedDeviceUserBindingRequestToJSON,
    PatchedEndpointDeviceRequestFromJSON,
    PatchedEndpointDeviceRequestToJSON,
    PatchedEnrollmentTokenRequestFromJSON,
    PatchedEnrollmentTokenRequestToJSON,
    PatchedFleetConnectorRequestFromJSON,
    PatchedFleetConnectorRequestToJSON,
    TokenViewFromJSON,
    TokenViewToJSON,
    TypeCreateFromJSON,
    TypeCreateToJSON,
    UsedByFromJSON,
    UsedByToJSON,
    UserSelfFromJSON,
    UserSelfToJSON,
    ValidationErrorFromJSON,
    ValidationErrorToJSON,
} from '../models/index';

export interface EndpointsAgentsConnectorsAuthFedCreateRequest {
    device: string;
}

export interface EndpointsAgentsConnectorsCheckInCreateRequest {
    deviceFactsRequest?: DeviceFactsRequest;
}

export interface EndpointsAgentsConnectorsCreateRequest {
    agentConnectorRequest: AgentConnectorRequest;
}

export interface EndpointsAgentsConnectorsDestroyRequest {
    connectorUuid: string;
}

export interface EndpointsAgentsConnectorsEnrollCreateRequest {
    enrollRequest: EnrollRequest;
}

export interface EndpointsAgentsConnectorsListRequest {
    enabled?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface EndpointsAgentsConnectorsMdmConfigCreateRequest {
    connectorUuid: string;
    mDMConfigRequest: MDMConfigRequest;
}

export interface EndpointsAgentsConnectorsPartialUpdateRequest {
    connectorUuid: string;
    patchedAgentConnectorRequest?: PatchedAgentConnectorRequest;
}

export interface EndpointsAgentsConnectorsRetrieveRequest {
    connectorUuid: string;
}

export interface EndpointsAgentsConnectorsUpdateRequest {
    connectorUuid: string;
    agentConnectorRequest: AgentConnectorRequest;
}

export interface EndpointsAgentsConnectorsUsedByListRequest {
    connectorUuid: string;
}

export interface EndpointsAgentsEnrollmentTokensCreateRequest {
    enrollmentTokenRequest: EnrollmentTokenRequest;
}

export interface EndpointsAgentsEnrollmentTokensDestroyRequest {
    tokenUuid: string;
}

export interface EndpointsAgentsEnrollmentTokensListRequest {
    connector?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    tokenUuid?: string;
}

export interface EndpointsAgentsEnrollmentTokensPartialUpdateRequest {
    tokenUuid: string;
    patchedEnrollmentTokenRequest?: PatchedEnrollmentTokenRequest;
}

export interface EndpointsAgentsEnrollmentTokensRetrieveRequest {
    tokenUuid: string;
}

export interface EndpointsAgentsEnrollmentTokensUpdateRequest {
    tokenUuid: string;
    enrollmentTokenRequest: EnrollmentTokenRequest;
}

export interface EndpointsAgentsEnrollmentTokensUsedByListRequest {
    tokenUuid: string;
}

export interface EndpointsAgentsEnrollmentTokensViewKeyRetrieveRequest {
    tokenUuid: string;
}

export interface EndpointsAgentsPssoRegisterDeviceCreateRequest {
    agentPSSODeviceRegistrationRequest: AgentPSSODeviceRegistrationRequest;
}

export interface EndpointsAgentsPssoRegisterUserCreateRequest {
    agentPSSOUserRegistrationRequest: AgentPSSOUserRegistrationRequest;
}

export interface EndpointsConnectorsDestroyRequest {
    connectorUuid: string;
}

export interface EndpointsConnectorsListRequest {
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface EndpointsConnectorsRetrieveRequest {
    connectorUuid: string;
}

export interface EndpointsConnectorsUsedByListRequest {
    connectorUuid: string;
}

export interface EndpointsDeviceAccessGroupsCreateRequest {
    deviceAccessGroupRequest: DeviceAccessGroupRequest;
}

export interface EndpointsDeviceAccessGroupsDestroyRequest {
    pbmUuid: string;
}

export interface EndpointsDeviceAccessGroupsListRequest {
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    pbmUuid?: string;
    search?: string;
}

export interface EndpointsDeviceAccessGroupsPartialUpdateRequest {
    pbmUuid: string;
    patchedDeviceAccessGroupRequest?: PatchedDeviceAccessGroupRequest;
}

export interface EndpointsDeviceAccessGroupsRetrieveRequest {
    pbmUuid: string;
}

export interface EndpointsDeviceAccessGroupsUpdateRequest {
    pbmUuid: string;
    deviceAccessGroupRequest: DeviceAccessGroupRequest;
}

export interface EndpointsDeviceAccessGroupsUsedByListRequest {
    pbmUuid: string;
}

export interface EndpointsDeviceBindingsCreateRequest {
    deviceUserBindingRequest: DeviceUserBindingRequest;
}

export interface EndpointsDeviceBindingsDestroyRequest {
    policyBindingUuid: string;
}

export interface EndpointsDeviceBindingsListRequest {
    enabled?: boolean;
    order?: number;
    ordering?: string;
    page?: number;
    pageSize?: number;
    policy?: string;
    policyIsnull?: boolean;
    search?: string;
    target?: string;
    targetIn?: Array<string>;
    timeout?: number;
}

export interface EndpointsDeviceBindingsPartialUpdateRequest {
    policyBindingUuid: string;
    patchedDeviceUserBindingRequest?: PatchedDeviceUserBindingRequest;
}

export interface EndpointsDeviceBindingsRetrieveRequest {
    policyBindingUuid: string;
}

export interface EndpointsDeviceBindingsUpdateRequest {
    policyBindingUuid: string;
    deviceUserBindingRequest: DeviceUserBindingRequest;
}

export interface EndpointsDeviceBindingsUsedByListRequest {
    policyBindingUuid: string;
}

export interface EndpointsDevicesDestroyRequest {
    deviceUuid: string;
}

export interface EndpointsDevicesListRequest {
    identifier?: string;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface EndpointsDevicesPartialUpdateRequest {
    deviceUuid: string;
    patchedEndpointDeviceRequest?: PatchedEndpointDeviceRequest;
}

export interface EndpointsDevicesRetrieveRequest {
    deviceUuid: string;
}

export interface EndpointsDevicesUpdateRequest {
    deviceUuid: string;
    endpointDeviceRequest: EndpointDeviceRequest;
}

export interface EndpointsDevicesUsedByListRequest {
    deviceUuid: string;
}

export interface EndpointsFleetConnectorsCreateRequest {
    fleetConnectorRequest: FleetConnectorRequest;
}

export interface EndpointsFleetConnectorsDestroyRequest {
    connectorUuid: string;
}

export interface EndpointsFleetConnectorsListRequest {
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface EndpointsFleetConnectorsPartialUpdateRequest {
    connectorUuid: string;
    patchedFleetConnectorRequest?: PatchedFleetConnectorRequest;
}

export interface EndpointsFleetConnectorsRetrieveRequest {
    connectorUuid: string;
}

export interface EndpointsFleetConnectorsUpdateRequest {
    connectorUuid: string;
    fleetConnectorRequest: FleetConnectorRequest;
}

export interface EndpointsFleetConnectorsUsedByListRequest {
    connectorUuid: string;
}

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

    /**
     * Creates request options for endpointsAgentsConnectorsAgentConfigRetrieve without sending the request
     */
    async endpointsAgentsConnectorsAgentConfigRetrieveRequestOpts(): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};


        let urlPath = `/endpoints/agents/connectors/agent_config/`;

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsAgentConfigRetrieveRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AgentConfig>> {
        const requestOptions = await this.endpointsAgentsConnectorsAgentConfigRetrieveRequestOpts();
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsAgentConfigRetrieve(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AgentConfig> {
        const response = await this.endpointsAgentsConnectorsAgentConfigRetrieveRaw(initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsConnectorsAuthFedCreate without sending the request
     */
    async endpointsAgentsConnectorsAuthFedCreateRequestOpts(requestParameters: EndpointsAgentsConnectorsAuthFedCreateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['device'] == null) {
            throw new runtime.RequiredError(
                'device',
                'Required parameter "device" was null or undefined when calling endpointsAgentsConnectorsAuthFedCreate().'
            );
        }

        const queryParameters: any = {};

        if (requestParameters['device'] != null) {
            queryParameters['device'] = requestParameters['device'];
        }

        const headerParameters: runtime.HTTPHeaders = {};


        let urlPath = `/endpoints/agents/connectors/auth_fed/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsAuthFedCreateRaw(requestParameters: EndpointsAgentsConnectorsAuthFedCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AgentTokenResponse>> {
        const requestOptions = await this.endpointsAgentsConnectorsAuthFedCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsAuthFedCreate(requestParameters: EndpointsAgentsConnectorsAuthFedCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AgentTokenResponse> {
        const response = await this.endpointsAgentsConnectorsAuthFedCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsConnectorsAuthIaCreate without sending the request
     */
    async endpointsAgentsConnectorsAuthIaCreateRequestOpts(): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};


        let urlPath = `/endpoints/agents/connectors/auth_ia/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsAuthIaCreateRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AgentAuthenticationResponse>> {
        const requestOptions = await this.endpointsAgentsConnectorsAuthIaCreateRequestOpts();
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsAuthIaCreate(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AgentAuthenticationResponse> {
        const response = await this.endpointsAgentsConnectorsAuthIaCreateRaw(initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsConnectorsCheckInCreate without sending the request
     */
    async endpointsAgentsConnectorsCheckInCreateRequestOpts(requestParameters: EndpointsAgentsConnectorsCheckInCreateRequest): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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


        let urlPath = `/endpoints/agents/connectors/check_in/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: DeviceFactsRequestToJSON(requestParameters['deviceFactsRequest']),
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsCheckInCreateRaw(requestParameters: EndpointsAgentsConnectorsCheckInCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const requestOptions = await this.endpointsAgentsConnectorsCheckInCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsCheckInCreate(requestParameters: EndpointsAgentsConnectorsCheckInCreateRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.endpointsAgentsConnectorsCheckInCreateRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for endpointsAgentsConnectorsCreate without sending the request
     */
    async endpointsAgentsConnectorsCreateRequestOpts(requestParameters: EndpointsAgentsConnectorsCreateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['agentConnectorRequest'] == null) {
            throw new runtime.RequiredError(
                'agentConnectorRequest',
                'Required parameter "agentConnectorRequest" was null or undefined when calling endpointsAgentsConnectorsCreate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/connectors/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AgentConnectorRequestToJSON(requestParameters['agentConnectorRequest']),
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsCreateRaw(requestParameters: EndpointsAgentsConnectorsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AgentConnector>> {
        const requestOptions = await this.endpointsAgentsConnectorsCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsCreate(requestParameters: EndpointsAgentsConnectorsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AgentConnector> {
        const response = await this.endpointsAgentsConnectorsCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsConnectorsDestroy without sending the request
     */
    async endpointsAgentsConnectorsDestroyRequestOpts(requestParameters: EndpointsAgentsConnectorsDestroyRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsAgentsConnectorsDestroy().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsDestroyRaw(requestParameters: EndpointsAgentsConnectorsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const requestOptions = await this.endpointsAgentsConnectorsDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsDestroy(requestParameters: EndpointsAgentsConnectorsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.endpointsAgentsConnectorsDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for endpointsAgentsConnectorsEnrollCreate without sending the request
     */
    async endpointsAgentsConnectorsEnrollCreateRequestOpts(requestParameters: EndpointsAgentsConnectorsEnrollCreateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['enrollRequest'] == null) {
            throw new runtime.RequiredError(
                'enrollRequest',
                'Required parameter "enrollRequest" was null or undefined when calling endpointsAgentsConnectorsEnrollCreate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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


        let urlPath = `/endpoints/agents/connectors/enroll/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: EnrollRequestToJSON(requestParameters['enrollRequest']),
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsEnrollCreateRaw(requestParameters: EndpointsAgentsConnectorsEnrollCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AgentTokenResponse>> {
        const requestOptions = await this.endpointsAgentsConnectorsEnrollCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsEnrollCreate(requestParameters: EndpointsAgentsConnectorsEnrollCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AgentTokenResponse> {
        const response = await this.endpointsAgentsConnectorsEnrollCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsConnectorsList without sending the request
     */
    async endpointsAgentsConnectorsListRequestOpts(requestParameters: EndpointsAgentsConnectorsListRequest): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

        if (requestParameters['enabled'] != null) {
            queryParameters['enabled'] = requestParameters['enabled'];
        }

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

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

        if (requestParameters['page'] != null) {
            queryParameters['page'] = requestParameters['page'];
        }

        if (requestParameters['pageSize'] != null) {
            queryParameters['page_size'] = requestParameters['pageSize'];
        }

        if (requestParameters['search'] != null) {
            queryParameters['search'] = requestParameters['search'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/connectors/`;

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsListRaw(requestParameters: EndpointsAgentsConnectorsListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedAgentConnectorList>> {
        const requestOptions = await this.endpointsAgentsConnectorsListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsList(requestParameters: EndpointsAgentsConnectorsListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedAgentConnectorList> {
        const response = await this.endpointsAgentsConnectorsListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsConnectorsMdmConfigCreate without sending the request
     */
    async endpointsAgentsConnectorsMdmConfigCreateRequestOpts(requestParameters: EndpointsAgentsConnectorsMdmConfigCreateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsAgentsConnectorsMdmConfigCreate().'
            );
        }

        if (requestParameters['mDMConfigRequest'] == null) {
            throw new runtime.RequiredError(
                'mDMConfigRequest',
                'Required parameter "mDMConfigRequest" was null or undefined when calling endpointsAgentsConnectorsMdmConfigCreate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/connectors/{connector_uuid}/mdm_config/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MDMConfigRequestToJSON(requestParameters['mDMConfigRequest']),
        };
    }

    /**
     * Generate configuration for MDM systems to deploy authentik Agent
     */
    async endpointsAgentsConnectorsMdmConfigCreateRaw(requestParameters: EndpointsAgentsConnectorsMdmConfigCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MDMConfigResponse>> {
        const requestOptions = await this.endpointsAgentsConnectorsMdmConfigCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Generate configuration for MDM systems to deploy authentik Agent
     */
    async endpointsAgentsConnectorsMdmConfigCreate(requestParameters: EndpointsAgentsConnectorsMdmConfigCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MDMConfigResponse> {
        const response = await this.endpointsAgentsConnectorsMdmConfigCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsConnectorsPartialUpdate without sending the request
     */
    async endpointsAgentsConnectorsPartialUpdateRequestOpts(requestParameters: EndpointsAgentsConnectorsPartialUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsAgentsConnectorsPartialUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedAgentConnectorRequestToJSON(requestParameters['patchedAgentConnectorRequest']),
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsPartialUpdateRaw(requestParameters: EndpointsAgentsConnectorsPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AgentConnector>> {
        const requestOptions = await this.endpointsAgentsConnectorsPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsPartialUpdate(requestParameters: EndpointsAgentsConnectorsPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AgentConnector> {
        const response = await this.endpointsAgentsConnectorsPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsConnectorsRetrieve without sending the request
     */
    async endpointsAgentsConnectorsRetrieveRequestOpts(requestParameters: EndpointsAgentsConnectorsRetrieveRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsAgentsConnectorsRetrieve().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsRetrieveRaw(requestParameters: EndpointsAgentsConnectorsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AgentConnector>> {
        const requestOptions = await this.endpointsAgentsConnectorsRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsRetrieve(requestParameters: EndpointsAgentsConnectorsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AgentConnector> {
        const response = await this.endpointsAgentsConnectorsRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsConnectorsUpdate without sending the request
     */
    async endpointsAgentsConnectorsUpdateRequestOpts(requestParameters: EndpointsAgentsConnectorsUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsAgentsConnectorsUpdate().'
            );
        }

        if (requestParameters['agentConnectorRequest'] == null) {
            throw new runtime.RequiredError(
                'agentConnectorRequest',
                'Required parameter "agentConnectorRequest" was null or undefined when calling endpointsAgentsConnectorsUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: AgentConnectorRequestToJSON(requestParameters['agentConnectorRequest']),
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsUpdateRaw(requestParameters: EndpointsAgentsConnectorsUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AgentConnector>> {
        const requestOptions = await this.endpointsAgentsConnectorsUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsConnectorsUpdate(requestParameters: EndpointsAgentsConnectorsUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AgentConnector> {
        const response = await this.endpointsAgentsConnectorsUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsConnectorsUsedByList without sending the request
     */
    async endpointsAgentsConnectorsUsedByListRequestOpts(requestParameters: EndpointsAgentsConnectorsUsedByListRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsAgentsConnectorsUsedByList().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/connectors/{connector_uuid}/used_by/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Get a list of all objects that use this object
     */
    async endpointsAgentsConnectorsUsedByListRaw(requestParameters: EndpointsAgentsConnectorsUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        const requestOptions = await this.endpointsAgentsConnectorsUsedByListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Get a list of all objects that use this object
     */
    async endpointsAgentsConnectorsUsedByList(requestParameters: EndpointsAgentsConnectorsUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UsedBy>> {
        const response = await this.endpointsAgentsConnectorsUsedByListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsEnrollmentTokensCreate without sending the request
     */
    async endpointsAgentsEnrollmentTokensCreateRequestOpts(requestParameters: EndpointsAgentsEnrollmentTokensCreateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['enrollmentTokenRequest'] == null) {
            throw new runtime.RequiredError(
                'enrollmentTokenRequest',
                'Required parameter "enrollmentTokenRequest" was null or undefined when calling endpointsAgentsEnrollmentTokensCreate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/enrollment_tokens/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: EnrollmentTokenRequestToJSON(requestParameters['enrollmentTokenRequest']),
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensCreateRaw(requestParameters: EndpointsAgentsEnrollmentTokensCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnrollmentToken>> {
        const requestOptions = await this.endpointsAgentsEnrollmentTokensCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensCreate(requestParameters: EndpointsAgentsEnrollmentTokensCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnrollmentToken> {
        const response = await this.endpointsAgentsEnrollmentTokensCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsEnrollmentTokensDestroy without sending the request
     */
    async endpointsAgentsEnrollmentTokensDestroyRequestOpts(requestParameters: EndpointsAgentsEnrollmentTokensDestroyRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['tokenUuid'] == null) {
            throw new runtime.RequiredError(
                'tokenUuid',
                'Required parameter "tokenUuid" was null or undefined when calling endpointsAgentsEnrollmentTokensDestroy().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/enrollment_tokens/{token_uuid}/`;
        urlPath = urlPath.replace(`{${"token_uuid"}}`, encodeURIComponent(String(requestParameters['tokenUuid'])));

        return {
            path: urlPath,
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensDestroyRaw(requestParameters: EndpointsAgentsEnrollmentTokensDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const requestOptions = await this.endpointsAgentsEnrollmentTokensDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensDestroy(requestParameters: EndpointsAgentsEnrollmentTokensDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.endpointsAgentsEnrollmentTokensDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for endpointsAgentsEnrollmentTokensList without sending the request
     */
    async endpointsAgentsEnrollmentTokensListRequestOpts(requestParameters: EndpointsAgentsEnrollmentTokensListRequest): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

        if (requestParameters['connector'] != null) {
            queryParameters['connector'] = requestParameters['connector'];
        }

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

        if (requestParameters['page'] != null) {
            queryParameters['page'] = requestParameters['page'];
        }

        if (requestParameters['pageSize'] != null) {
            queryParameters['page_size'] = requestParameters['pageSize'];
        }

        if (requestParameters['search'] != null) {
            queryParameters['search'] = requestParameters['search'];
        }

        if (requestParameters['tokenUuid'] != null) {
            queryParameters['token_uuid'] = requestParameters['tokenUuid'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/enrollment_tokens/`;

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensListRaw(requestParameters: EndpointsAgentsEnrollmentTokensListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedEnrollmentTokenList>> {
        const requestOptions = await this.endpointsAgentsEnrollmentTokensListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensList(requestParameters: EndpointsAgentsEnrollmentTokensListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedEnrollmentTokenList> {
        const response = await this.endpointsAgentsEnrollmentTokensListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsEnrollmentTokensPartialUpdate without sending the request
     */
    async endpointsAgentsEnrollmentTokensPartialUpdateRequestOpts(requestParameters: EndpointsAgentsEnrollmentTokensPartialUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['tokenUuid'] == null) {
            throw new runtime.RequiredError(
                'tokenUuid',
                'Required parameter "tokenUuid" was null or undefined when calling endpointsAgentsEnrollmentTokensPartialUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/enrollment_tokens/{token_uuid}/`;
        urlPath = urlPath.replace(`{${"token_uuid"}}`, encodeURIComponent(String(requestParameters['tokenUuid'])));

        return {
            path: urlPath,
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedEnrollmentTokenRequestToJSON(requestParameters['patchedEnrollmentTokenRequest']),
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensPartialUpdateRaw(requestParameters: EndpointsAgentsEnrollmentTokensPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnrollmentToken>> {
        const requestOptions = await this.endpointsAgentsEnrollmentTokensPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensPartialUpdate(requestParameters: EndpointsAgentsEnrollmentTokensPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnrollmentToken> {
        const response = await this.endpointsAgentsEnrollmentTokensPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsEnrollmentTokensRetrieve without sending the request
     */
    async endpointsAgentsEnrollmentTokensRetrieveRequestOpts(requestParameters: EndpointsAgentsEnrollmentTokensRetrieveRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['tokenUuid'] == null) {
            throw new runtime.RequiredError(
                'tokenUuid',
                'Required parameter "tokenUuid" was null or undefined when calling endpointsAgentsEnrollmentTokensRetrieve().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/enrollment_tokens/{token_uuid}/`;
        urlPath = urlPath.replace(`{${"token_uuid"}}`, encodeURIComponent(String(requestParameters['tokenUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensRetrieveRaw(requestParameters: EndpointsAgentsEnrollmentTokensRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnrollmentToken>> {
        const requestOptions = await this.endpointsAgentsEnrollmentTokensRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensRetrieve(requestParameters: EndpointsAgentsEnrollmentTokensRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnrollmentToken> {
        const response = await this.endpointsAgentsEnrollmentTokensRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsEnrollmentTokensUpdate without sending the request
     */
    async endpointsAgentsEnrollmentTokensUpdateRequestOpts(requestParameters: EndpointsAgentsEnrollmentTokensUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['tokenUuid'] == null) {
            throw new runtime.RequiredError(
                'tokenUuid',
                'Required parameter "tokenUuid" was null or undefined when calling endpointsAgentsEnrollmentTokensUpdate().'
            );
        }

        if (requestParameters['enrollmentTokenRequest'] == null) {
            throw new runtime.RequiredError(
                'enrollmentTokenRequest',
                'Required parameter "enrollmentTokenRequest" was null or undefined when calling endpointsAgentsEnrollmentTokensUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/enrollment_tokens/{token_uuid}/`;
        urlPath = urlPath.replace(`{${"token_uuid"}}`, encodeURIComponent(String(requestParameters['tokenUuid'])));

        return {
            path: urlPath,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: EnrollmentTokenRequestToJSON(requestParameters['enrollmentTokenRequest']),
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensUpdateRaw(requestParameters: EndpointsAgentsEnrollmentTokensUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnrollmentToken>> {
        const requestOptions = await this.endpointsAgentsEnrollmentTokensUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsAgentsEnrollmentTokensUpdate(requestParameters: EndpointsAgentsEnrollmentTokensUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnrollmentToken> {
        const response = await this.endpointsAgentsEnrollmentTokensUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsEnrollmentTokensUsedByList without sending the request
     */
    async endpointsAgentsEnrollmentTokensUsedByListRequestOpts(requestParameters: EndpointsAgentsEnrollmentTokensUsedByListRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['tokenUuid'] == null) {
            throw new runtime.RequiredError(
                'tokenUuid',
                'Required parameter "tokenUuid" was null or undefined when calling endpointsAgentsEnrollmentTokensUsedByList().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/enrollment_tokens/{token_uuid}/used_by/`;
        urlPath = urlPath.replace(`{${"token_uuid"}}`, encodeURIComponent(String(requestParameters['tokenUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Get a list of all objects that use this object
     */
    async endpointsAgentsEnrollmentTokensUsedByListRaw(requestParameters: EndpointsAgentsEnrollmentTokensUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        const requestOptions = await this.endpointsAgentsEnrollmentTokensUsedByListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Get a list of all objects that use this object
     */
    async endpointsAgentsEnrollmentTokensUsedByList(requestParameters: EndpointsAgentsEnrollmentTokensUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UsedBy>> {
        const response = await this.endpointsAgentsEnrollmentTokensUsedByListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsEnrollmentTokensViewKeyRetrieve without sending the request
     */
    async endpointsAgentsEnrollmentTokensViewKeyRetrieveRequestOpts(requestParameters: EndpointsAgentsEnrollmentTokensViewKeyRetrieveRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['tokenUuid'] == null) {
            throw new runtime.RequiredError(
                'tokenUuid',
                'Required parameter "tokenUuid" was null or undefined when calling endpointsAgentsEnrollmentTokensViewKeyRetrieve().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/agents/enrollment_tokens/{token_uuid}/view_key/`;
        urlPath = urlPath.replace(`{${"token_uuid"}}`, encodeURIComponent(String(requestParameters['tokenUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Return token key and log access
     */
    async endpointsAgentsEnrollmentTokensViewKeyRetrieveRaw(requestParameters: EndpointsAgentsEnrollmentTokensViewKeyRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TokenView>> {
        const requestOptions = await this.endpointsAgentsEnrollmentTokensViewKeyRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Return token key and log access
     */
    async endpointsAgentsEnrollmentTokensViewKeyRetrieve(requestParameters: EndpointsAgentsEnrollmentTokensViewKeyRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TokenView> {
        const response = await this.endpointsAgentsEnrollmentTokensViewKeyRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsPssoRegisterDeviceCreate without sending the request
     */
    async endpointsAgentsPssoRegisterDeviceCreateRequestOpts(requestParameters: EndpointsAgentsPssoRegisterDeviceCreateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['agentPSSODeviceRegistrationRequest'] == null) {
            throw new runtime.RequiredError(
                'agentPSSODeviceRegistrationRequest',
                'Required parameter "agentPSSODeviceRegistrationRequest" was null or undefined when calling endpointsAgentsPssoRegisterDeviceCreate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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


        let urlPath = `/endpoints/agents/psso/register/device/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AgentPSSODeviceRegistrationRequestToJSON(requestParameters['agentPSSODeviceRegistrationRequest']),
        };
    }

    /**
     */
    async endpointsAgentsPssoRegisterDeviceCreateRaw(requestParameters: EndpointsAgentsPssoRegisterDeviceCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AgentPSSODeviceRegistrationResponse>> {
        const requestOptions = await this.endpointsAgentsPssoRegisterDeviceCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     */
    async endpointsAgentsPssoRegisterDeviceCreate(requestParameters: EndpointsAgentsPssoRegisterDeviceCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AgentPSSODeviceRegistrationResponse> {
        const response = await this.endpointsAgentsPssoRegisterDeviceCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsAgentsPssoRegisterUserCreate without sending the request
     */
    async endpointsAgentsPssoRegisterUserCreateRequestOpts(requestParameters: EndpointsAgentsPssoRegisterUserCreateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['agentPSSOUserRegistrationRequest'] == null) {
            throw new runtime.RequiredError(
                'agentPSSOUserRegistrationRequest',
                'Required parameter "agentPSSOUserRegistrationRequest" was null or undefined when calling endpointsAgentsPssoRegisterUserCreate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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


        let urlPath = `/endpoints/agents/psso/register/user/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AgentPSSOUserRegistrationRequestToJSON(requestParameters['agentPSSOUserRegistrationRequest']),
        };
    }

    /**
     */
    async endpointsAgentsPssoRegisterUserCreateRaw(requestParameters: EndpointsAgentsPssoRegisterUserCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSelf>> {
        const requestOptions = await this.endpointsAgentsPssoRegisterUserCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     */
    async endpointsAgentsPssoRegisterUserCreate(requestParameters: EndpointsAgentsPssoRegisterUserCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSelf> {
        const response = await this.endpointsAgentsPssoRegisterUserCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsConnectorsDestroy without sending the request
     */
    async endpointsConnectorsDestroyRequestOpts(requestParameters: EndpointsConnectorsDestroyRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsConnectorsDestroy().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Connector Viewset
     */
    async endpointsConnectorsDestroyRaw(requestParameters: EndpointsConnectorsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const requestOptions = await this.endpointsConnectorsDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Connector Viewset
     */
    async endpointsConnectorsDestroy(requestParameters: EndpointsConnectorsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.endpointsConnectorsDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for endpointsConnectorsList without sending the request
     */
    async endpointsConnectorsListRequestOpts(requestParameters: EndpointsConnectorsListRequest): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

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

        if (requestParameters['page'] != null) {
            queryParameters['page'] = requestParameters['page'];
        }

        if (requestParameters['pageSize'] != null) {
            queryParameters['page_size'] = requestParameters['pageSize'];
        }

        if (requestParameters['search'] != null) {
            queryParameters['search'] = requestParameters['search'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/connectors/`;

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Connector Viewset
     */
    async endpointsConnectorsListRaw(requestParameters: EndpointsConnectorsListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedConnectorList>> {
        const requestOptions = await this.endpointsConnectorsListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Connector Viewset
     */
    async endpointsConnectorsList(requestParameters: EndpointsConnectorsListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedConnectorList> {
        const response = await this.endpointsConnectorsListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsConnectorsRetrieve without sending the request
     */
    async endpointsConnectorsRetrieveRequestOpts(requestParameters: EndpointsConnectorsRetrieveRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsConnectorsRetrieve().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Connector Viewset
     */
    async endpointsConnectorsRetrieveRaw(requestParameters: EndpointsConnectorsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Connector>> {
        const requestOptions = await this.endpointsConnectorsRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Connector Viewset
     */
    async endpointsConnectorsRetrieve(requestParameters: EndpointsConnectorsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Connector> {
        const response = await this.endpointsConnectorsRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsConnectorsTypesList without sending the request
     */
    async endpointsConnectorsTypesListRequestOpts(): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/connectors/types/`;

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Get all creatable types
     */
    async endpointsConnectorsTypesListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<TypeCreate>>> {
        const requestOptions = await this.endpointsConnectorsTypesListRequestOpts();
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Get all creatable types
     */
    async endpointsConnectorsTypesList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<TypeCreate>> {
        const response = await this.endpointsConnectorsTypesListRaw(initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsConnectorsUsedByList without sending the request
     */
    async endpointsConnectorsUsedByListRequestOpts(requestParameters: EndpointsConnectorsUsedByListRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsConnectorsUsedByList().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/connectors/{connector_uuid}/used_by/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Get a list of all objects that use this object
     */
    async endpointsConnectorsUsedByListRaw(requestParameters: EndpointsConnectorsUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        const requestOptions = await this.endpointsConnectorsUsedByListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Get a list of all objects that use this object
     */
    async endpointsConnectorsUsedByList(requestParameters: EndpointsConnectorsUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UsedBy>> {
        const response = await this.endpointsConnectorsUsedByListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceAccessGroupsCreate without sending the request
     */
    async endpointsDeviceAccessGroupsCreateRequestOpts(requestParameters: EndpointsDeviceAccessGroupsCreateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['deviceAccessGroupRequest'] == null) {
            throw new runtime.RequiredError(
                'deviceAccessGroupRequest',
                'Required parameter "deviceAccessGroupRequest" was null or undefined when calling endpointsDeviceAccessGroupsCreate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_access_groups/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: DeviceAccessGroupRequestToJSON(requestParameters['deviceAccessGroupRequest']),
        };
    }

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsCreateRaw(requestParameters: EndpointsDeviceAccessGroupsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeviceAccessGroup>> {
        const requestOptions = await this.endpointsDeviceAccessGroupsCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsCreate(requestParameters: EndpointsDeviceAccessGroupsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeviceAccessGroup> {
        const response = await this.endpointsDeviceAccessGroupsCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceAccessGroupsDestroy without sending the request
     */
    async endpointsDeviceAccessGroupsDestroyRequestOpts(requestParameters: EndpointsDeviceAccessGroupsDestroyRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['pbmUuid'] == null) {
            throw new runtime.RequiredError(
                'pbmUuid',
                'Required parameter "pbmUuid" was null or undefined when calling endpointsDeviceAccessGroupsDestroy().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_access_groups/{pbm_uuid}/`;
        urlPath = urlPath.replace(`{${"pbm_uuid"}}`, encodeURIComponent(String(requestParameters['pbmUuid'])));

        return {
            path: urlPath,
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsDestroyRaw(requestParameters: EndpointsDeviceAccessGroupsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const requestOptions = await this.endpointsDeviceAccessGroupsDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsDestroy(requestParameters: EndpointsDeviceAccessGroupsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.endpointsDeviceAccessGroupsDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for endpointsDeviceAccessGroupsList without sending the request
     */
    async endpointsDeviceAccessGroupsListRequestOpts(requestParameters: EndpointsDeviceAccessGroupsListRequest): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

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

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

        if (requestParameters['page'] != null) {
            queryParameters['page'] = requestParameters['page'];
        }

        if (requestParameters['pageSize'] != null) {
            queryParameters['page_size'] = requestParameters['pageSize'];
        }

        if (requestParameters['pbmUuid'] != null) {
            queryParameters['pbm_uuid'] = requestParameters['pbmUuid'];
        }

        if (requestParameters['search'] != null) {
            queryParameters['search'] = requestParameters['search'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_access_groups/`;

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsListRaw(requestParameters: EndpointsDeviceAccessGroupsListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedDeviceAccessGroupList>> {
        const requestOptions = await this.endpointsDeviceAccessGroupsListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsList(requestParameters: EndpointsDeviceAccessGroupsListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedDeviceAccessGroupList> {
        const response = await this.endpointsDeviceAccessGroupsListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceAccessGroupsPartialUpdate without sending the request
     */
    async endpointsDeviceAccessGroupsPartialUpdateRequestOpts(requestParameters: EndpointsDeviceAccessGroupsPartialUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['pbmUuid'] == null) {
            throw new runtime.RequiredError(
                'pbmUuid',
                'Required parameter "pbmUuid" was null or undefined when calling endpointsDeviceAccessGroupsPartialUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_access_groups/{pbm_uuid}/`;
        urlPath = urlPath.replace(`{${"pbm_uuid"}}`, encodeURIComponent(String(requestParameters['pbmUuid'])));

        return {
            path: urlPath,
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedDeviceAccessGroupRequestToJSON(requestParameters['patchedDeviceAccessGroupRequest']),
        };
    }

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsPartialUpdateRaw(requestParameters: EndpointsDeviceAccessGroupsPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeviceAccessGroup>> {
        const requestOptions = await this.endpointsDeviceAccessGroupsPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsPartialUpdate(requestParameters: EndpointsDeviceAccessGroupsPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeviceAccessGroup> {
        const response = await this.endpointsDeviceAccessGroupsPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceAccessGroupsRetrieve without sending the request
     */
    async endpointsDeviceAccessGroupsRetrieveRequestOpts(requestParameters: EndpointsDeviceAccessGroupsRetrieveRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['pbmUuid'] == null) {
            throw new runtime.RequiredError(
                'pbmUuid',
                'Required parameter "pbmUuid" was null or undefined when calling endpointsDeviceAccessGroupsRetrieve().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_access_groups/{pbm_uuid}/`;
        urlPath = urlPath.replace(`{${"pbm_uuid"}}`, encodeURIComponent(String(requestParameters['pbmUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsRetrieveRaw(requestParameters: EndpointsDeviceAccessGroupsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeviceAccessGroup>> {
        const requestOptions = await this.endpointsDeviceAccessGroupsRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsRetrieve(requestParameters: EndpointsDeviceAccessGroupsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeviceAccessGroup> {
        const response = await this.endpointsDeviceAccessGroupsRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceAccessGroupsUpdate without sending the request
     */
    async endpointsDeviceAccessGroupsUpdateRequestOpts(requestParameters: EndpointsDeviceAccessGroupsUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['pbmUuid'] == null) {
            throw new runtime.RequiredError(
                'pbmUuid',
                'Required parameter "pbmUuid" was null or undefined when calling endpointsDeviceAccessGroupsUpdate().'
            );
        }

        if (requestParameters['deviceAccessGroupRequest'] == null) {
            throw new runtime.RequiredError(
                'deviceAccessGroupRequest',
                'Required parameter "deviceAccessGroupRequest" was null or undefined when calling endpointsDeviceAccessGroupsUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_access_groups/{pbm_uuid}/`;
        urlPath = urlPath.replace(`{${"pbm_uuid"}}`, encodeURIComponent(String(requestParameters['pbmUuid'])));

        return {
            path: urlPath,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: DeviceAccessGroupRequestToJSON(requestParameters['deviceAccessGroupRequest']),
        };
    }

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsUpdateRaw(requestParameters: EndpointsDeviceAccessGroupsUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeviceAccessGroup>> {
        const requestOptions = await this.endpointsDeviceAccessGroupsUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * DeviceAccessGroup Viewset
     */
    async endpointsDeviceAccessGroupsUpdate(requestParameters: EndpointsDeviceAccessGroupsUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeviceAccessGroup> {
        const response = await this.endpointsDeviceAccessGroupsUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceAccessGroupsUsedByList without sending the request
     */
    async endpointsDeviceAccessGroupsUsedByListRequestOpts(requestParameters: EndpointsDeviceAccessGroupsUsedByListRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['pbmUuid'] == null) {
            throw new runtime.RequiredError(
                'pbmUuid',
                'Required parameter "pbmUuid" was null or undefined when calling endpointsDeviceAccessGroupsUsedByList().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_access_groups/{pbm_uuid}/used_by/`;
        urlPath = urlPath.replace(`{${"pbm_uuid"}}`, encodeURIComponent(String(requestParameters['pbmUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Get a list of all objects that use this object
     */
    async endpointsDeviceAccessGroupsUsedByListRaw(requestParameters: EndpointsDeviceAccessGroupsUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        const requestOptions = await this.endpointsDeviceAccessGroupsUsedByListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Get a list of all objects that use this object
     */
    async endpointsDeviceAccessGroupsUsedByList(requestParameters: EndpointsDeviceAccessGroupsUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UsedBy>> {
        const response = await this.endpointsDeviceAccessGroupsUsedByListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceBindingsCreate without sending the request
     */
    async endpointsDeviceBindingsCreateRequestOpts(requestParameters: EndpointsDeviceBindingsCreateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['deviceUserBindingRequest'] == null) {
            throw new runtime.RequiredError(
                'deviceUserBindingRequest',
                'Required parameter "deviceUserBindingRequest" was null or undefined when calling endpointsDeviceBindingsCreate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_bindings/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: DeviceUserBindingRequestToJSON(requestParameters['deviceUserBindingRequest']),
        };
    }

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsCreateRaw(requestParameters: EndpointsDeviceBindingsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeviceUserBinding>> {
        const requestOptions = await this.endpointsDeviceBindingsCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsCreate(requestParameters: EndpointsDeviceBindingsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeviceUserBinding> {
        const response = await this.endpointsDeviceBindingsCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceBindingsDestroy without sending the request
     */
    async endpointsDeviceBindingsDestroyRequestOpts(requestParameters: EndpointsDeviceBindingsDestroyRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['policyBindingUuid'] == null) {
            throw new runtime.RequiredError(
                'policyBindingUuid',
                'Required parameter "policyBindingUuid" was null or undefined when calling endpointsDeviceBindingsDestroy().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_bindings/{policy_binding_uuid}/`;
        urlPath = urlPath.replace(`{${"policy_binding_uuid"}}`, encodeURIComponent(String(requestParameters['policyBindingUuid'])));

        return {
            path: urlPath,
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsDestroyRaw(requestParameters: EndpointsDeviceBindingsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const requestOptions = await this.endpointsDeviceBindingsDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsDestroy(requestParameters: EndpointsDeviceBindingsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.endpointsDeviceBindingsDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for endpointsDeviceBindingsList without sending the request
     */
    async endpointsDeviceBindingsListRequestOpts(requestParameters: EndpointsDeviceBindingsListRequest): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

        if (requestParameters['enabled'] != null) {
            queryParameters['enabled'] = requestParameters['enabled'];
        }

        if (requestParameters['order'] != null) {
            queryParameters['order'] = requestParameters['order'];
        }

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

        if (requestParameters['page'] != null) {
            queryParameters['page'] = requestParameters['page'];
        }

        if (requestParameters['pageSize'] != null) {
            queryParameters['page_size'] = requestParameters['pageSize'];
        }

        if (requestParameters['policy'] != null) {
            queryParameters['policy'] = requestParameters['policy'];
        }

        if (requestParameters['policyIsnull'] != null) {
            queryParameters['policy__isnull'] = requestParameters['policyIsnull'];
        }

        if (requestParameters['search'] != null) {
            queryParameters['search'] = requestParameters['search'];
        }

        if (requestParameters['target'] != null) {
            queryParameters['target'] = requestParameters['target'];
        }

        if (requestParameters['targetIn'] != null) {
            queryParameters['target_in'] = requestParameters['targetIn'];
        }

        if (requestParameters['timeout'] != null) {
            queryParameters['timeout'] = requestParameters['timeout'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_bindings/`;

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsListRaw(requestParameters: EndpointsDeviceBindingsListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedDeviceUserBindingList>> {
        const requestOptions = await this.endpointsDeviceBindingsListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsList(requestParameters: EndpointsDeviceBindingsListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedDeviceUserBindingList> {
        const response = await this.endpointsDeviceBindingsListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceBindingsPartialUpdate without sending the request
     */
    async endpointsDeviceBindingsPartialUpdateRequestOpts(requestParameters: EndpointsDeviceBindingsPartialUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['policyBindingUuid'] == null) {
            throw new runtime.RequiredError(
                'policyBindingUuid',
                'Required parameter "policyBindingUuid" was null or undefined when calling endpointsDeviceBindingsPartialUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_bindings/{policy_binding_uuid}/`;
        urlPath = urlPath.replace(`{${"policy_binding_uuid"}}`, encodeURIComponent(String(requestParameters['policyBindingUuid'])));

        return {
            path: urlPath,
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedDeviceUserBindingRequestToJSON(requestParameters['patchedDeviceUserBindingRequest']),
        };
    }

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsPartialUpdateRaw(requestParameters: EndpointsDeviceBindingsPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeviceUserBinding>> {
        const requestOptions = await this.endpointsDeviceBindingsPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsPartialUpdate(requestParameters: EndpointsDeviceBindingsPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeviceUserBinding> {
        const response = await this.endpointsDeviceBindingsPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceBindingsRetrieve without sending the request
     */
    async endpointsDeviceBindingsRetrieveRequestOpts(requestParameters: EndpointsDeviceBindingsRetrieveRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['policyBindingUuid'] == null) {
            throw new runtime.RequiredError(
                'policyBindingUuid',
                'Required parameter "policyBindingUuid" was null or undefined when calling endpointsDeviceBindingsRetrieve().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_bindings/{policy_binding_uuid}/`;
        urlPath = urlPath.replace(`{${"policy_binding_uuid"}}`, encodeURIComponent(String(requestParameters['policyBindingUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsRetrieveRaw(requestParameters: EndpointsDeviceBindingsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeviceUserBinding>> {
        const requestOptions = await this.endpointsDeviceBindingsRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsRetrieve(requestParameters: EndpointsDeviceBindingsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeviceUserBinding> {
        const response = await this.endpointsDeviceBindingsRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceBindingsUpdate without sending the request
     */
    async endpointsDeviceBindingsUpdateRequestOpts(requestParameters: EndpointsDeviceBindingsUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['policyBindingUuid'] == null) {
            throw new runtime.RequiredError(
                'policyBindingUuid',
                'Required parameter "policyBindingUuid" was null or undefined when calling endpointsDeviceBindingsUpdate().'
            );
        }

        if (requestParameters['deviceUserBindingRequest'] == null) {
            throw new runtime.RequiredError(
                'deviceUserBindingRequest',
                'Required parameter "deviceUserBindingRequest" was null or undefined when calling endpointsDeviceBindingsUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_bindings/{policy_binding_uuid}/`;
        urlPath = urlPath.replace(`{${"policy_binding_uuid"}}`, encodeURIComponent(String(requestParameters['policyBindingUuid'])));

        return {
            path: urlPath,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: DeviceUserBindingRequestToJSON(requestParameters['deviceUserBindingRequest']),
        };
    }

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsUpdateRaw(requestParameters: EndpointsDeviceBindingsUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeviceUserBinding>> {
        const requestOptions = await this.endpointsDeviceBindingsUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PolicyBinding Viewset
     */
    async endpointsDeviceBindingsUpdate(requestParameters: EndpointsDeviceBindingsUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeviceUserBinding> {
        const response = await this.endpointsDeviceBindingsUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDeviceBindingsUsedByList without sending the request
     */
    async endpointsDeviceBindingsUsedByListRequestOpts(requestParameters: EndpointsDeviceBindingsUsedByListRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['policyBindingUuid'] == null) {
            throw new runtime.RequiredError(
                'policyBindingUuid',
                'Required parameter "policyBindingUuid" was null or undefined when calling endpointsDeviceBindingsUsedByList().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/device_bindings/{policy_binding_uuid}/used_by/`;
        urlPath = urlPath.replace(`{${"policy_binding_uuid"}}`, encodeURIComponent(String(requestParameters['policyBindingUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Get a list of all objects that use this object
     */
    async endpointsDeviceBindingsUsedByListRaw(requestParameters: EndpointsDeviceBindingsUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        const requestOptions = await this.endpointsDeviceBindingsUsedByListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Get a list of all objects that use this object
     */
    async endpointsDeviceBindingsUsedByList(requestParameters: EndpointsDeviceBindingsUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UsedBy>> {
        const response = await this.endpointsDeviceBindingsUsedByListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDevicesDestroy without sending the request
     */
    async endpointsDevicesDestroyRequestOpts(requestParameters: EndpointsDevicesDestroyRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['deviceUuid'] == null) {
            throw new runtime.RequiredError(
                'deviceUuid',
                'Required parameter "deviceUuid" was null or undefined when calling endpointsDevicesDestroy().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/devices/{device_uuid}/`;
        urlPath = urlPath.replace(`{${"device_uuid"}}`, encodeURIComponent(String(requestParameters['deviceUuid'])));

        return {
            path: urlPath,
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesDestroyRaw(requestParameters: EndpointsDevicesDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const requestOptions = await this.endpointsDevicesDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesDestroy(requestParameters: EndpointsDevicesDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.endpointsDevicesDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for endpointsDevicesList without sending the request
     */
    async endpointsDevicesListRequestOpts(requestParameters: EndpointsDevicesListRequest): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

        if (requestParameters['identifier'] != null) {
            queryParameters['identifier'] = requestParameters['identifier'];
        }

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

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

        if (requestParameters['page'] != null) {
            queryParameters['page'] = requestParameters['page'];
        }

        if (requestParameters['pageSize'] != null) {
            queryParameters['page_size'] = requestParameters['pageSize'];
        }

        if (requestParameters['search'] != null) {
            queryParameters['search'] = requestParameters['search'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/devices/`;

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesListRaw(requestParameters: EndpointsDevicesListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedEndpointDeviceList>> {
        const requestOptions = await this.endpointsDevicesListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesList(requestParameters: EndpointsDevicesListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedEndpointDeviceList> {
        const response = await this.endpointsDevicesListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDevicesPartialUpdate without sending the request
     */
    async endpointsDevicesPartialUpdateRequestOpts(requestParameters: EndpointsDevicesPartialUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['deviceUuid'] == null) {
            throw new runtime.RequiredError(
                'deviceUuid',
                'Required parameter "deviceUuid" was null or undefined when calling endpointsDevicesPartialUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/devices/{device_uuid}/`;
        urlPath = urlPath.replace(`{${"device_uuid"}}`, encodeURIComponent(String(requestParameters['deviceUuid'])));

        return {
            path: urlPath,
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedEndpointDeviceRequestToJSON(requestParameters['patchedEndpointDeviceRequest']),
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesPartialUpdateRaw(requestParameters: EndpointsDevicesPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EndpointDevice>> {
        const requestOptions = await this.endpointsDevicesPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesPartialUpdate(requestParameters: EndpointsDevicesPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EndpointDevice> {
        const response = await this.endpointsDevicesPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDevicesRetrieve without sending the request
     */
    async endpointsDevicesRetrieveRequestOpts(requestParameters: EndpointsDevicesRetrieveRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['deviceUuid'] == null) {
            throw new runtime.RequiredError(
                'deviceUuid',
                'Required parameter "deviceUuid" was null or undefined when calling endpointsDevicesRetrieve().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/devices/{device_uuid}/`;
        urlPath = urlPath.replace(`{${"device_uuid"}}`, encodeURIComponent(String(requestParameters['deviceUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesRetrieveRaw(requestParameters: EndpointsDevicesRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EndpointDeviceDetails>> {
        const requestOptions = await this.endpointsDevicesRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesRetrieve(requestParameters: EndpointsDevicesRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EndpointDeviceDetails> {
        const response = await this.endpointsDevicesRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDevicesSummaryRetrieve without sending the request
     */
    async endpointsDevicesSummaryRetrieveRequestOpts(): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/devices/summary/`;

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesSummaryRetrieveRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeviceSummary>> {
        const requestOptions = await this.endpointsDevicesSummaryRetrieveRequestOpts();
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesSummaryRetrieve(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeviceSummary> {
        const response = await this.endpointsDevicesSummaryRetrieveRaw(initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDevicesUpdate without sending the request
     */
    async endpointsDevicesUpdateRequestOpts(requestParameters: EndpointsDevicesUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['deviceUuid'] == null) {
            throw new runtime.RequiredError(
                'deviceUuid',
                'Required parameter "deviceUuid" was null or undefined when calling endpointsDevicesUpdate().'
            );
        }

        if (requestParameters['endpointDeviceRequest'] == null) {
            throw new runtime.RequiredError(
                'endpointDeviceRequest',
                'Required parameter "endpointDeviceRequest" was null or undefined when calling endpointsDevicesUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/devices/{device_uuid}/`;
        urlPath = urlPath.replace(`{${"device_uuid"}}`, encodeURIComponent(String(requestParameters['deviceUuid'])));

        return {
            path: urlPath,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: EndpointDeviceRequestToJSON(requestParameters['endpointDeviceRequest']),
        };
    }

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesUpdateRaw(requestParameters: EndpointsDevicesUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EndpointDevice>> {
        const requestOptions = await this.endpointsDevicesUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to add a used_by endpoint to return a list of all objects using this object
     */
    async endpointsDevicesUpdate(requestParameters: EndpointsDevicesUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EndpointDevice> {
        const response = await this.endpointsDevicesUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsDevicesUsedByList without sending the request
     */
    async endpointsDevicesUsedByListRequestOpts(requestParameters: EndpointsDevicesUsedByListRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['deviceUuid'] == null) {
            throw new runtime.RequiredError(
                'deviceUuid',
                'Required parameter "deviceUuid" was null or undefined when calling endpointsDevicesUsedByList().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/devices/{device_uuid}/used_by/`;
        urlPath = urlPath.replace(`{${"device_uuid"}}`, encodeURIComponent(String(requestParameters['deviceUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Get a list of all objects that use this object
     */
    async endpointsDevicesUsedByListRaw(requestParameters: EndpointsDevicesUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        const requestOptions = await this.endpointsDevicesUsedByListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Get a list of all objects that use this object
     */
    async endpointsDevicesUsedByList(requestParameters: EndpointsDevicesUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UsedBy>> {
        const response = await this.endpointsDevicesUsedByListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsFleetConnectorsCreate without sending the request
     */
    async endpointsFleetConnectorsCreateRequestOpts(requestParameters: EndpointsFleetConnectorsCreateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['fleetConnectorRequest'] == null) {
            throw new runtime.RequiredError(
                'fleetConnectorRequest',
                'Required parameter "fleetConnectorRequest" was null or undefined when calling endpointsFleetConnectorsCreate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/fleet/connectors/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FleetConnectorRequestToJSON(requestParameters['fleetConnectorRequest']),
        };
    }

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsCreateRaw(requestParameters: EndpointsFleetConnectorsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FleetConnector>> {
        const requestOptions = await this.endpointsFleetConnectorsCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsCreate(requestParameters: EndpointsFleetConnectorsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FleetConnector> {
        const response = await this.endpointsFleetConnectorsCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsFleetConnectorsDestroy without sending the request
     */
    async endpointsFleetConnectorsDestroyRequestOpts(requestParameters: EndpointsFleetConnectorsDestroyRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsFleetConnectorsDestroy().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/fleet/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsDestroyRaw(requestParameters: EndpointsFleetConnectorsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const requestOptions = await this.endpointsFleetConnectorsDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsDestroy(requestParameters: EndpointsFleetConnectorsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.endpointsFleetConnectorsDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for endpointsFleetConnectorsList without sending the request
     */
    async endpointsFleetConnectorsListRequestOpts(requestParameters: EndpointsFleetConnectorsListRequest): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

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

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

        if (requestParameters['page'] != null) {
            queryParameters['page'] = requestParameters['page'];
        }

        if (requestParameters['pageSize'] != null) {
            queryParameters['page_size'] = requestParameters['pageSize'];
        }

        if (requestParameters['search'] != null) {
            queryParameters['search'] = requestParameters['search'];
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/fleet/connectors/`;

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsListRaw(requestParameters: EndpointsFleetConnectorsListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedFleetConnectorList>> {
        const requestOptions = await this.endpointsFleetConnectorsListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsList(requestParameters: EndpointsFleetConnectorsListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedFleetConnectorList> {
        const response = await this.endpointsFleetConnectorsListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsFleetConnectorsPartialUpdate without sending the request
     */
    async endpointsFleetConnectorsPartialUpdateRequestOpts(requestParameters: EndpointsFleetConnectorsPartialUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsFleetConnectorsPartialUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/fleet/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedFleetConnectorRequestToJSON(requestParameters['patchedFleetConnectorRequest']),
        };
    }

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsPartialUpdateRaw(requestParameters: EndpointsFleetConnectorsPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FleetConnector>> {
        const requestOptions = await this.endpointsFleetConnectorsPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsPartialUpdate(requestParameters: EndpointsFleetConnectorsPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FleetConnector> {
        const response = await this.endpointsFleetConnectorsPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsFleetConnectorsRetrieve without sending the request
     */
    async endpointsFleetConnectorsRetrieveRequestOpts(requestParameters: EndpointsFleetConnectorsRetrieveRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsFleetConnectorsRetrieve().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/fleet/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsRetrieveRaw(requestParameters: EndpointsFleetConnectorsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FleetConnector>> {
        const requestOptions = await this.endpointsFleetConnectorsRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsRetrieve(requestParameters: EndpointsFleetConnectorsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FleetConnector> {
        const response = await this.endpointsFleetConnectorsRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsFleetConnectorsUpdate without sending the request
     */
    async endpointsFleetConnectorsUpdateRequestOpts(requestParameters: EndpointsFleetConnectorsUpdateRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsFleetConnectorsUpdate().'
            );
        }

        if (requestParameters['fleetConnectorRequest'] == null) {
            throw new runtime.RequiredError(
                'fleetConnectorRequest',
                'Required parameter "fleetConnectorRequest" was null or undefined when calling endpointsFleetConnectorsUpdate().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/fleet/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: FleetConnectorRequestToJSON(requestParameters['fleetConnectorRequest']),
        };
    }

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsUpdateRaw(requestParameters: EndpointsFleetConnectorsUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FleetConnector>> {
        const requestOptions = await this.endpointsFleetConnectorsUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * FleetConnector Viewset
     */
    async endpointsFleetConnectorsUpdate(requestParameters: EndpointsFleetConnectorsUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FleetConnector> {
        const response = await this.endpointsFleetConnectorsUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for endpointsFleetConnectorsUsedByList without sending the request
     */
    async endpointsFleetConnectorsUsedByListRequestOpts(requestParameters: EndpointsFleetConnectorsUsedByListRequest): Promise<runtime.RequestOpts> {
        if (requestParameters['connectorUuid'] == null) {
            throw new runtime.RequiredError(
                'connectorUuid',
                'Required parameter "connectorUuid" was null or undefined when calling endpointsFleetConnectorsUsedByList().'
            );
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.accessToken) {
            const token = this.configuration.accessToken;
            const tokenString = await token("authentik", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/endpoints/fleet/connectors/{connector_uuid}/used_by/`;
        urlPath = urlPath.replace(`{${"connector_uuid"}}`, encodeURIComponent(String(requestParameters['connectorUuid'])));

        return {
            path: urlPath,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        };
    }

    /**
     * Get a list of all objects that use this object
     */
    async endpointsFleetConnectorsUsedByListRaw(requestParameters: EndpointsFleetConnectorsUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        const requestOptions = await this.endpointsFleetConnectorsUsedByListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Get a list of all objects that use this object
     */
    async endpointsFleetConnectorsUsedByList(requestParameters: EndpointsFleetConnectorsUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UsedBy>> {
        const response = await this.endpointsFleetConnectorsUsedByListRaw(requestParameters, initOverrides);
        return await response.value();
    }

}