/* tslint:disable */
/* eslint-disable */
/**
 * authentik
 * Making authentication simple.
 *
 * The version of the OpenAPI document: 2026.5.0-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 type {
    AgentAuthenticationResponse,
    AgentConfig,
    AgentConnector,
    AgentConnectorRequest,
    AgentPSSODeviceRegistrationRequest,
    AgentPSSODeviceRegistrationResponse,
    AgentPSSOUserRegistrationRequest,
    AgentTokenResponse,
    AppleIndependentSecureEnclave,
    AppleIndependentSecureEnclaveRequest,
    Connector,
    DeviceAccessGroup,
    DeviceAccessGroupRequest,
    DeviceFactsRequest,
    DeviceSummary,
    DeviceUserBinding,
    DeviceUserBindingRequest,
    EndpointDevice,
    EndpointDeviceDetails,
    EndpointDeviceRequest,
    EnrollmentToken,
    EnrollmentTokenRequest,
    EnrollRequest,
    FleetConnector,
    FleetConnectorRequest,
    GoogleChromeConnector,
    GoogleChromeConnectorRequest,
    MDMConfigRequest,
    MDMConfigResponse,
    PaginatedAgentConnectorList,
    PaginatedAppleIndependentSecureEnclaveList,
    PaginatedConnectorList,
    PaginatedDeviceAccessGroupList,
    PaginatedDeviceUserBindingList,
    PaginatedEndpointDeviceList,
    PaginatedEnrollmentTokenList,
    PaginatedFleetConnectorList,
    PaginatedGoogleChromeConnectorList,
    PatchedAgentConnectorRequest,
    PatchedAppleIndependentSecureEnclaveRequest,
    PatchedDeviceAccessGroupRequest,
    PatchedDeviceUserBindingRequest,
    PatchedEndpointDeviceRequest,
    PatchedEnrollmentTokenRequest,
    PatchedFleetConnectorRequest,
    PatchedGoogleChromeConnectorRequest,
    TokenView,
    TypeCreate,
    UsedBy,
    UserSelf,
} from "../models/index";
import {
    AgentAuthenticationResponseFromJSON,
    AgentConfigFromJSON,
    AgentConnectorFromJSON,
    AgentConnectorRequestToJSON,
    AgentPSSODeviceRegistrationRequestToJSON,
    AgentPSSODeviceRegistrationResponseFromJSON,
    AgentPSSOUserRegistrationRequestToJSON,
    AgentTokenResponseFromJSON,
    AppleIndependentSecureEnclaveFromJSON,
    AppleIndependentSecureEnclaveRequestToJSON,
    ConnectorFromJSON,
    DeviceAccessGroupFromJSON,
    DeviceAccessGroupRequestToJSON,
    DeviceFactsRequestToJSON,
    DeviceSummaryFromJSON,
    DeviceUserBindingFromJSON,
    DeviceUserBindingRequestToJSON,
    EndpointDeviceDetailsFromJSON,
    EndpointDeviceFromJSON,
    EndpointDeviceRequestToJSON,
    EnrollmentTokenFromJSON,
    EnrollmentTokenRequestToJSON,
    EnrollRequestToJSON,
    FleetConnectorFromJSON,
    FleetConnectorRequestToJSON,
    GoogleChromeConnectorFromJSON,
    GoogleChromeConnectorRequestToJSON,
    MDMConfigRequestToJSON,
    MDMConfigResponseFromJSON,
    PaginatedAgentConnectorListFromJSON,
    PaginatedAppleIndependentSecureEnclaveListFromJSON,
    PaginatedConnectorListFromJSON,
    PaginatedDeviceAccessGroupListFromJSON,
    PaginatedDeviceUserBindingListFromJSON,
    PaginatedEndpointDeviceListFromJSON,
    PaginatedEnrollmentTokenListFromJSON,
    PaginatedFleetConnectorListFromJSON,
    PaginatedGoogleChromeConnectorListFromJSON,
    PatchedAgentConnectorRequestToJSON,
    PatchedAppleIndependentSecureEnclaveRequestToJSON,
    PatchedDeviceAccessGroupRequestToJSON,
    PatchedDeviceUserBindingRequestToJSON,
    PatchedEndpointDeviceRequestToJSON,
    PatchedEnrollmentTokenRequestToJSON,
    PatchedFleetConnectorRequestToJSON,
    PatchedGoogleChromeConnectorRequestToJSON,
    TokenViewFromJSON,
    TypeCreateFromJSON,
    UsedByFromJSON,
    UserSelfFromJSON,
} from "../models/index";
import * as runtime from "../runtime";

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 EndpointsAgentsPssoIseCreateRequest {
    appleIndependentSecureEnclaveRequest: AppleIndependentSecureEnclaveRequest;
}

export interface EndpointsAgentsPssoIseDestroyRequest {
    uuid: string;
}

export interface EndpointsAgentsPssoIseListRequest {
    appleEnclaveKeyId?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    user?: number;
}

export interface EndpointsAgentsPssoIsePartialUpdateRequest {
    uuid: string;
    patchedAppleIndependentSecureEnclaveRequest?: PatchedAppleIndependentSecureEnclaveRequest;
}

export interface EndpointsAgentsPssoIseRetrieveRequest {
    uuid: string;
}

export interface EndpointsAgentsPssoIseUpdateRequest {
    uuid: string;
    appleIndependentSecureEnclaveRequest: AppleIndependentSecureEnclaveRequest;
}

export interface EndpointsAgentsPssoIseUsedByListRequest {
    uuid: 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 interface EndpointsGoogleChromeConnectorsCreateRequest {
    googleChromeConnectorRequest: GoogleChromeConnectorRequest;
}

export interface EndpointsGoogleChromeConnectorsDestroyRequest {
    connectorUuid: string;
}

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

export interface EndpointsGoogleChromeConnectorsPartialUpdateRequest {
    connectorUuid: string;
    patchedGoogleChromeConnectorRequest?: PatchedGoogleChromeConnectorRequest;
}

export interface EndpointsGoogleChromeConnectorsRetrieveRequest {
    connectorUuid: string;
}

export interface EndpointsGoogleChromeConnectorsUpdateRequest {
    connectorUuid: string;
    googleChromeConnectorRequest: GoogleChromeConnectorRequest;
}

export interface EndpointsGoogleChromeConnectorsUsedByListRequest {
    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 endpointsAgentsPssoIseCreate without sending the request
     */
    async endpointsAgentsPssoIseCreateRequestOpts(
        requestParameters: EndpointsAgentsPssoIseCreateRequest,
    ): Promise<runtime.RequestOpts> {
        if (requestParameters["appleIndependentSecureEnclaveRequest"] == null) {
            throw new runtime.RequiredError(
                "appleIndependentSecureEnclaveRequest",
                'Required parameter "appleIndependentSecureEnclaveRequest" was null or undefined when calling endpointsAgentsPssoIseCreate().',
            );
        }

        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/psso/ise/`;

        return {
            path: urlPath,
            method: "POST",
            headers: headerParameters,
            query: queryParameters,
            body: AppleIndependentSecureEnclaveRequestToJSON(
                requestParameters["appleIndependentSecureEnclaveRequest"],
            ),
        };
    }

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

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

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

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

        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/psso/ise/{uuid}/`;
        urlPath = urlPath.replace(
            `{${"uuid"}}`,
            encodeURIComponent(String(requestParameters["uuid"])),
        );

        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 endpointsAgentsPssoIseDestroyRaw(
        requestParameters: EndpointsAgentsPssoIseDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.endpointsAgentsPssoIseDestroyRequestOpts(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 endpointsAgentsPssoIseDestroy(
        requestParameters: EndpointsAgentsPssoIseDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.endpointsAgentsPssoIseDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for endpointsAgentsPssoIseList without sending the request
     */
    async endpointsAgentsPssoIseListRequestOpts(
        requestParameters: EndpointsAgentsPssoIseListRequest,
    ): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

        if (requestParameters["appleEnclaveKeyId"] != null) {
            queryParameters["apple_enclave_key_id"] = requestParameters["appleEnclaveKeyId"];
        }

        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["user"] != null) {
            queryParameters["user"] = requestParameters["user"];
        }

        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/psso/ise/`;

        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 endpointsAgentsPssoIseListRaw(
        requestParameters: EndpointsAgentsPssoIseListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedAppleIndependentSecureEnclaveList>> {
        const requestOptions = await this.endpointsAgentsPssoIseListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

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

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

        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/psso/ise/{uuid}/`;
        urlPath = urlPath.replace(
            `{${"uuid"}}`,
            encodeURIComponent(String(requestParameters["uuid"])),
        );

        return {
            path: urlPath,
            method: "PATCH",
            headers: headerParameters,
            query: queryParameters,
            body: PatchedAppleIndependentSecureEnclaveRequestToJSON(
                requestParameters["patchedAppleIndependentSecureEnclaveRequest"],
            ),
        };
    }

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

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

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

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

        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/psso/ise/{uuid}/`;
        urlPath = urlPath.replace(
            `{${"uuid"}}`,
            encodeURIComponent(String(requestParameters["uuid"])),
        );

        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 endpointsAgentsPssoIseRetrieveRaw(
        requestParameters: EndpointsAgentsPssoIseRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<AppleIndependentSecureEnclave>> {
        const requestOptions =
            await this.endpointsAgentsPssoIseRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

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

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

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

        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/psso/ise/{uuid}/`;
        urlPath = urlPath.replace(
            `{${"uuid"}}`,
            encodeURIComponent(String(requestParameters["uuid"])),
        );

        return {
            path: urlPath,
            method: "PUT",
            headers: headerParameters,
            query: queryParameters,
            body: AppleIndependentSecureEnclaveRequestToJSON(
                requestParameters["appleIndependentSecureEnclaveRequest"],
            ),
        };
    }

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

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

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

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

        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/psso/ise/{uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"uuid"}}`,
            encodeURIComponent(String(requestParameters["uuid"])),
        );

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

    /**
     * Get a list of all objects that use this object
     */
    async endpointsAgentsPssoIseUsedByListRaw(
        requestParameters: EndpointsAgentsPssoIseUsedByListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        const requestOptions =
            await this.endpointsAgentsPssoIseUsedByListRequestOpts(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 endpointsAgentsPssoIseUsedByList(
        requestParameters: EndpointsAgentsPssoIseUsedByListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<Array<UsedBy>> {
        const response = await this.endpointsAgentsPssoIseUsedByListRaw(
            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();
    }

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

        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/google_chrome/connectors/`;

        return {
            path: urlPath,
            method: "POST",
            headers: headerParameters,
            query: queryParameters,
            body: GoogleChromeConnectorRequestToJSON(
                requestParameters["googleChromeConnectorRequest"],
            ),
        };
    }

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsCreateRaw(
        requestParameters: EndpointsGoogleChromeConnectorsCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<GoogleChromeConnector>> {
        const requestOptions =
            await this.endpointsGoogleChromeConnectorsCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsCreate(
        requestParameters: EndpointsGoogleChromeConnectorsCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<GoogleChromeConnector> {
        const response = await this.endpointsGoogleChromeConnectorsCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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/google_chrome/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(
            `{${"connector_uuid"}}`,
            encodeURIComponent(String(requestParameters["connectorUuid"])),
        );

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

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsDestroyRaw(
        requestParameters: EndpointsGoogleChromeConnectorsDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.endpointsGoogleChromeConnectorsDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsDestroy(
        requestParameters: EndpointsGoogleChromeConnectorsDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.endpointsGoogleChromeConnectorsDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for endpointsGoogleChromeConnectorsList without sending the request
     */
    async endpointsGoogleChromeConnectorsListRequestOpts(
        requestParameters: EndpointsGoogleChromeConnectorsListRequest,
    ): 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/google_chrome/connectors/`;

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

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsListRaw(
        requestParameters: EndpointsGoogleChromeConnectorsListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedGoogleChromeConnectorList>> {
        const requestOptions =
            await this.endpointsGoogleChromeConnectorsListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsList(
        requestParameters: EndpointsGoogleChromeConnectorsListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedGoogleChromeConnectorList> {
        const response = await this.endpointsGoogleChromeConnectorsListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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/google_chrome/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(
            `{${"connector_uuid"}}`,
            encodeURIComponent(String(requestParameters["connectorUuid"])),
        );

        return {
            path: urlPath,
            method: "PATCH",
            headers: headerParameters,
            query: queryParameters,
            body: PatchedGoogleChromeConnectorRequestToJSON(
                requestParameters["patchedGoogleChromeConnectorRequest"],
            ),
        };
    }

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsPartialUpdateRaw(
        requestParameters: EndpointsGoogleChromeConnectorsPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<GoogleChromeConnector>> {
        const requestOptions =
            await this.endpointsGoogleChromeConnectorsPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsPartialUpdate(
        requestParameters: EndpointsGoogleChromeConnectorsPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<GoogleChromeConnector> {
        const response = await this.endpointsGoogleChromeConnectorsPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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/google_chrome/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(
            `{${"connector_uuid"}}`,
            encodeURIComponent(String(requestParameters["connectorUuid"])),
        );

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

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsRetrieveRaw(
        requestParameters: EndpointsGoogleChromeConnectorsRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<GoogleChromeConnector>> {
        const requestOptions =
            await this.endpointsGoogleChromeConnectorsRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsRetrieve(
        requestParameters: EndpointsGoogleChromeConnectorsRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<GoogleChromeConnector> {
        const response = await this.endpointsGoogleChromeConnectorsRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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/google_chrome/connectors/{connector_uuid}/`;
        urlPath = urlPath.replace(
            `{${"connector_uuid"}}`,
            encodeURIComponent(String(requestParameters["connectorUuid"])),
        );

        return {
            path: urlPath,
            method: "PUT",
            headers: headerParameters,
            query: queryParameters,
            body: GoogleChromeConnectorRequestToJSON(
                requestParameters["googleChromeConnectorRequest"],
            ),
        };
    }

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsUpdateRaw(
        requestParameters: EndpointsGoogleChromeConnectorsUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<GoogleChromeConnector>> {
        const requestOptions =
            await this.endpointsGoogleChromeConnectorsUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * GoogleChromeConnector Viewset
     */
    async endpointsGoogleChromeConnectorsUpdate(
        requestParameters: EndpointsGoogleChromeConnectorsUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<GoogleChromeConnector> {
        const response = await this.endpointsGoogleChromeConnectorsUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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/google_chrome/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 endpointsGoogleChromeConnectorsUsedByListRaw(
        requestParameters: EndpointsGoogleChromeConnectorsUsedByListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        const requestOptions =
            await this.endpointsGoogleChromeConnectorsUsedByListRequestOpts(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 endpointsGoogleChromeConnectorsUsedByList(
        requestParameters: EndpointsGoogleChromeConnectorsUsedByListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<Array<UsedBy>> {
        const response = await this.endpointsGoogleChromeConnectorsUsedByListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }
}
