/* 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 {
    GoogleWorkspaceProviderMapping,
    GoogleWorkspaceProviderMappingRequest,
    KerberosSourcePropertyMapping,
    KerberosSourcePropertyMappingRequest,
    LDAPSourcePropertyMapping,
    LDAPSourcePropertyMappingRequest,
    MicrosoftEntraProviderMapping,
    MicrosoftEntraProviderMappingRequest,
    NotificationWebhookMapping,
    NotificationWebhookMappingRequest,
    OAuthSourcePropertyMapping,
    OAuthSourcePropertyMappingRequest,
    PaginatedGoogleWorkspaceProviderMappingList,
    PaginatedKerberosSourcePropertyMappingList,
    PaginatedLDAPSourcePropertyMappingList,
    PaginatedMicrosoftEntraProviderMappingList,
    PaginatedNotificationWebhookMappingList,
    PaginatedOAuthSourcePropertyMappingList,
    PaginatedPlexSourcePropertyMappingList,
    PaginatedPropertyMappingList,
    PaginatedRACPropertyMappingList,
    PaginatedRadiusProviderPropertyMappingList,
    PaginatedSAMLPropertyMappingList,
    PaginatedSAMLSourcePropertyMappingList,
    PaginatedSCIMMappingList,
    PaginatedSCIMSourcePropertyMappingList,
    PaginatedScopeMappingList,
    PaginatedTelegramSourcePropertyMappingList,
    PatchedGoogleWorkspaceProviderMappingRequest,
    PatchedKerberosSourcePropertyMappingRequest,
    PatchedLDAPSourcePropertyMappingRequest,
    PatchedMicrosoftEntraProviderMappingRequest,
    PatchedNotificationWebhookMappingRequest,
    PatchedOAuthSourcePropertyMappingRequest,
    PatchedPlexSourcePropertyMappingRequest,
    PatchedRACPropertyMappingRequest,
    PatchedRadiusProviderPropertyMappingRequest,
    PatchedSAMLPropertyMappingRequest,
    PatchedSAMLSourcePropertyMappingRequest,
    PatchedSCIMMappingRequest,
    PatchedSCIMSourcePropertyMappingRequest,
    PatchedScopeMappingRequest,
    PatchedTelegramSourcePropertyMappingRequest,
    PlexSourcePropertyMapping,
    PlexSourcePropertyMappingRequest,
    PropertyMapping,
    PropertyMappingTestRequest,
    PropertyMappingTestResult,
    RACPropertyMapping,
    RACPropertyMappingRequest,
    RadiusProviderPropertyMapping,
    RadiusProviderPropertyMappingRequest,
    SAMLPropertyMapping,
    SAMLPropertyMappingRequest,
    SAMLSourcePropertyMapping,
    SAMLSourcePropertyMappingRequest,
    SCIMMapping,
    SCIMMappingRequest,
    SCIMSourcePropertyMapping,
    SCIMSourcePropertyMappingRequest,
    ScopeMapping,
    ScopeMappingRequest,
    TelegramSourcePropertyMapping,
    TelegramSourcePropertyMappingRequest,
    TypeCreate,
    UsedBy,
} from "../models/index";
import {
    GoogleWorkspaceProviderMappingFromJSON,
    GoogleWorkspaceProviderMappingRequestToJSON,
    KerberosSourcePropertyMappingFromJSON,
    KerberosSourcePropertyMappingRequestToJSON,
    LDAPSourcePropertyMappingFromJSON,
    LDAPSourcePropertyMappingRequestToJSON,
    MicrosoftEntraProviderMappingFromJSON,
    MicrosoftEntraProviderMappingRequestToJSON,
    NotificationWebhookMappingFromJSON,
    NotificationWebhookMappingRequestToJSON,
    OAuthSourcePropertyMappingFromJSON,
    OAuthSourcePropertyMappingRequestToJSON,
    PaginatedGoogleWorkspaceProviderMappingListFromJSON,
    PaginatedKerberosSourcePropertyMappingListFromJSON,
    PaginatedLDAPSourcePropertyMappingListFromJSON,
    PaginatedMicrosoftEntraProviderMappingListFromJSON,
    PaginatedNotificationWebhookMappingListFromJSON,
    PaginatedOAuthSourcePropertyMappingListFromJSON,
    PaginatedPlexSourcePropertyMappingListFromJSON,
    PaginatedPropertyMappingListFromJSON,
    PaginatedRACPropertyMappingListFromJSON,
    PaginatedRadiusProviderPropertyMappingListFromJSON,
    PaginatedSAMLPropertyMappingListFromJSON,
    PaginatedSAMLSourcePropertyMappingListFromJSON,
    PaginatedSCIMMappingListFromJSON,
    PaginatedSCIMSourcePropertyMappingListFromJSON,
    PaginatedScopeMappingListFromJSON,
    PaginatedTelegramSourcePropertyMappingListFromJSON,
    PatchedGoogleWorkspaceProviderMappingRequestToJSON,
    PatchedKerberosSourcePropertyMappingRequestToJSON,
    PatchedLDAPSourcePropertyMappingRequestToJSON,
    PatchedMicrosoftEntraProviderMappingRequestToJSON,
    PatchedNotificationWebhookMappingRequestToJSON,
    PatchedOAuthSourcePropertyMappingRequestToJSON,
    PatchedPlexSourcePropertyMappingRequestToJSON,
    PatchedRACPropertyMappingRequestToJSON,
    PatchedRadiusProviderPropertyMappingRequestToJSON,
    PatchedSAMLPropertyMappingRequestToJSON,
    PatchedSAMLSourcePropertyMappingRequestToJSON,
    PatchedSCIMMappingRequestToJSON,
    PatchedSCIMSourcePropertyMappingRequestToJSON,
    PatchedScopeMappingRequestToJSON,
    PatchedTelegramSourcePropertyMappingRequestToJSON,
    PlexSourcePropertyMappingFromJSON,
    PlexSourcePropertyMappingRequestToJSON,
    PropertyMappingFromJSON,
    PropertyMappingTestRequestToJSON,
    PropertyMappingTestResultFromJSON,
    RACPropertyMappingFromJSON,
    RACPropertyMappingRequestToJSON,
    RadiusProviderPropertyMappingFromJSON,
    RadiusProviderPropertyMappingRequestToJSON,
    SAMLPropertyMappingFromJSON,
    SAMLPropertyMappingRequestToJSON,
    SAMLSourcePropertyMappingFromJSON,
    SAMLSourcePropertyMappingRequestToJSON,
    SCIMMappingFromJSON,
    SCIMMappingRequestToJSON,
    SCIMSourcePropertyMappingFromJSON,
    SCIMSourcePropertyMappingRequestToJSON,
    ScopeMappingFromJSON,
    ScopeMappingRequestToJSON,
    TelegramSourcePropertyMappingFromJSON,
    TelegramSourcePropertyMappingRequestToJSON,
    TypeCreateFromJSON,
    UsedByFromJSON,
} from "../models/index";
import * as runtime from "../runtime";

export interface PropertymappingsAllDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsAllListRequest {
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface PropertymappingsAllRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsAllTestCreateRequest {
    pmUuid: string;
    formatResult?: boolean;
    propertyMappingTestRequest?: PropertyMappingTestRequest;
}

export interface PropertymappingsAllUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsNotificationCreateRequest {
    notificationWebhookMappingRequest: NotificationWebhookMappingRequest;
}

export interface PropertymappingsNotificationDestroyRequest {
    pmUuid: string;
}

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

export interface PropertymappingsNotificationPartialUpdateRequest {
    pmUuid: string;
    patchedNotificationWebhookMappingRequest?: PatchedNotificationWebhookMappingRequest;
}

export interface PropertymappingsNotificationRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsNotificationUpdateRequest {
    pmUuid: string;
    notificationWebhookMappingRequest: NotificationWebhookMappingRequest;
}

export interface PropertymappingsNotificationUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderGoogleWorkspaceCreateRequest {
    googleWorkspaceProviderMappingRequest: GoogleWorkspaceProviderMappingRequest;
}

export interface PropertymappingsProviderGoogleWorkspaceDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderGoogleWorkspaceListRequest {
    expression?: string;
    managed?: Array<string>;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    pmUuid?: string;
    search?: string;
}

export interface PropertymappingsProviderGoogleWorkspacePartialUpdateRequest {
    pmUuid: string;
    patchedGoogleWorkspaceProviderMappingRequest?: PatchedGoogleWorkspaceProviderMappingRequest;
}

export interface PropertymappingsProviderGoogleWorkspaceRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderGoogleWorkspaceUpdateRequest {
    pmUuid: string;
    googleWorkspaceProviderMappingRequest: GoogleWorkspaceProviderMappingRequest;
}

export interface PropertymappingsProviderGoogleWorkspaceUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderMicrosoftEntraCreateRequest {
    microsoftEntraProviderMappingRequest: MicrosoftEntraProviderMappingRequest;
}

export interface PropertymappingsProviderMicrosoftEntraDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderMicrosoftEntraListRequest {
    expression?: string;
    managed?: Array<string>;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    pmUuid?: string;
    search?: string;
}

export interface PropertymappingsProviderMicrosoftEntraPartialUpdateRequest {
    pmUuid: string;
    patchedMicrosoftEntraProviderMappingRequest?: PatchedMicrosoftEntraProviderMappingRequest;
}

export interface PropertymappingsProviderMicrosoftEntraRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderMicrosoftEntraUpdateRequest {
    pmUuid: string;
    microsoftEntraProviderMappingRequest: MicrosoftEntraProviderMappingRequest;
}

export interface PropertymappingsProviderMicrosoftEntraUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderRacCreateRequest {
    rACPropertyMappingRequest: RACPropertyMappingRequest;
}

export interface PropertymappingsProviderRacDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderRacListRequest {
    managed?: Array<string>;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface PropertymappingsProviderRacPartialUpdateRequest {
    pmUuid: string;
    patchedRACPropertyMappingRequest?: PatchedRACPropertyMappingRequest;
}

export interface PropertymappingsProviderRacRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderRacUpdateRequest {
    pmUuid: string;
    rACPropertyMappingRequest: RACPropertyMappingRequest;
}

export interface PropertymappingsProviderRacUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderRadiusCreateRequest {
    radiusProviderPropertyMappingRequest: RadiusProviderPropertyMappingRequest;
}

export interface PropertymappingsProviderRadiusDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderRadiusListRequest {
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface PropertymappingsProviderRadiusPartialUpdateRequest {
    pmUuid: string;
    patchedRadiusProviderPropertyMappingRequest?: PatchedRadiusProviderPropertyMappingRequest;
}

export interface PropertymappingsProviderRadiusRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderRadiusUpdateRequest {
    pmUuid: string;
    radiusProviderPropertyMappingRequest: RadiusProviderPropertyMappingRequest;
}

export interface PropertymappingsProviderRadiusUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderSamlCreateRequest {
    sAMLPropertyMappingRequest: SAMLPropertyMappingRequest;
}

export interface PropertymappingsProviderSamlDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderSamlListRequest {
    friendlyName?: string;
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    samlName?: string;
    search?: string;
}

export interface PropertymappingsProviderSamlPartialUpdateRequest {
    pmUuid: string;
    patchedSAMLPropertyMappingRequest?: PatchedSAMLPropertyMappingRequest;
}

export interface PropertymappingsProviderSamlRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderSamlUpdateRequest {
    pmUuid: string;
    sAMLPropertyMappingRequest: SAMLPropertyMappingRequest;
}

export interface PropertymappingsProviderSamlUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderScimCreateRequest {
    sCIMMappingRequest: SCIMMappingRequest;
}

export interface PropertymappingsProviderScimDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderScimListRequest {
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface PropertymappingsProviderScimPartialUpdateRequest {
    pmUuid: string;
    patchedSCIMMappingRequest?: PatchedSCIMMappingRequest;
}

export interface PropertymappingsProviderScimRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderScimUpdateRequest {
    pmUuid: string;
    sCIMMappingRequest: SCIMMappingRequest;
}

export interface PropertymappingsProviderScimUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderScopeCreateRequest {
    scopeMappingRequest: ScopeMappingRequest;
}

export interface PropertymappingsProviderScopeDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderScopeListRequest {
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    scopeName?: string;
    search?: string;
}

export interface PropertymappingsProviderScopePartialUpdateRequest {
    pmUuid: string;
    patchedScopeMappingRequest?: PatchedScopeMappingRequest;
}

export interface PropertymappingsProviderScopeRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsProviderScopeUpdateRequest {
    pmUuid: string;
    scopeMappingRequest: ScopeMappingRequest;
}

export interface PropertymappingsProviderScopeUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceKerberosCreateRequest {
    kerberosSourcePropertyMappingRequest: KerberosSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceKerberosDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceKerberosListRequest {
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface PropertymappingsSourceKerberosPartialUpdateRequest {
    pmUuid: string;
    patchedKerberosSourcePropertyMappingRequest?: PatchedKerberosSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceKerberosRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceKerberosUpdateRequest {
    pmUuid: string;
    kerberosSourcePropertyMappingRequest: KerberosSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceKerberosUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceLdapCreateRequest {
    lDAPSourcePropertyMappingRequest: LDAPSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceLdapDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceLdapListRequest {
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface PropertymappingsSourceLdapPartialUpdateRequest {
    pmUuid: string;
    patchedLDAPSourcePropertyMappingRequest?: PatchedLDAPSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceLdapRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceLdapUpdateRequest {
    pmUuid: string;
    lDAPSourcePropertyMappingRequest: LDAPSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceLdapUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceOauthCreateRequest {
    oAuthSourcePropertyMappingRequest: OAuthSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceOauthDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceOauthListRequest {
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface PropertymappingsSourceOauthPartialUpdateRequest {
    pmUuid: string;
    patchedOAuthSourcePropertyMappingRequest?: PatchedOAuthSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceOauthRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceOauthUpdateRequest {
    pmUuid: string;
    oAuthSourcePropertyMappingRequest: OAuthSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceOauthUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsSourcePlexCreateRequest {
    plexSourcePropertyMappingRequest: PlexSourcePropertyMappingRequest;
}

export interface PropertymappingsSourcePlexDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsSourcePlexListRequest {
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface PropertymappingsSourcePlexPartialUpdateRequest {
    pmUuid: string;
    patchedPlexSourcePropertyMappingRequest?: PatchedPlexSourcePropertyMappingRequest;
}

export interface PropertymappingsSourcePlexRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsSourcePlexUpdateRequest {
    pmUuid: string;
    plexSourcePropertyMappingRequest: PlexSourcePropertyMappingRequest;
}

export interface PropertymappingsSourcePlexUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceSamlCreateRequest {
    sAMLSourcePropertyMappingRequest: SAMLSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceSamlDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceSamlListRequest {
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface PropertymappingsSourceSamlPartialUpdateRequest {
    pmUuid: string;
    patchedSAMLSourcePropertyMappingRequest?: PatchedSAMLSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceSamlRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceSamlUpdateRequest {
    pmUuid: string;
    sAMLSourcePropertyMappingRequest: SAMLSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceSamlUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceScimCreateRequest {
    sCIMSourcePropertyMappingRequest: SCIMSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceScimDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceScimListRequest {
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface PropertymappingsSourceScimPartialUpdateRequest {
    pmUuid: string;
    patchedSCIMSourcePropertyMappingRequest?: PatchedSCIMSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceScimRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceScimUpdateRequest {
    pmUuid: string;
    sCIMSourcePropertyMappingRequest: SCIMSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceScimUsedByListRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceTelegramCreateRequest {
    telegramSourcePropertyMappingRequest: TelegramSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceTelegramDestroyRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceTelegramListRequest {
    managed?: Array<string>;
    managedIsnull?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface PropertymappingsSourceTelegramPartialUpdateRequest {
    pmUuid: string;
    patchedTelegramSourcePropertyMappingRequest?: PatchedTelegramSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceTelegramRetrieveRequest {
    pmUuid: string;
}

export interface PropertymappingsSourceTelegramUpdateRequest {
    pmUuid: string;
    telegramSourcePropertyMappingRequest: TelegramSourcePropertyMappingRequest;
}

export interface PropertymappingsSourceTelegramUsedByListRequest {
    pmUuid: string;
}

/**
 *
 */
export class PropertymappingsApi extends runtime.BaseAPI {
    /**
     * Creates request options for propertymappingsAllDestroy without sending the request
     */
    async propertymappingsAllDestroyRequestOpts(
        requestParameters: PropertymappingsAllDestroyRequest,
    ): Promise<runtime.RequestOpts> {
        if (requestParameters["pmUuid"] == null) {
            throw new runtime.RequiredError(
                "pmUuid",
                'Required parameter "pmUuid" was null or undefined when calling propertymappingsAllDestroy().',
            );
        }

        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 = `/propertymappings/all/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * PropertyMapping Viewset
     */
    async propertymappingsAllDestroyRaw(
        requestParameters: PropertymappingsAllDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions = await this.propertymappingsAllDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * PropertyMapping Viewset
     */
    async propertymappingsAllDestroy(
        requestParameters: PropertymappingsAllDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsAllDestroyRaw(requestParameters, initOverrides);
    }

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

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

        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 = `/propertymappings/all/`;

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

    /**
     * PropertyMapping Viewset
     */
    async propertymappingsAllListRaw(
        requestParameters: PropertymappingsAllListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedPropertyMappingList>> {
        const requestOptions = await this.propertymappingsAllListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PropertyMapping Viewset
     */
    async propertymappingsAllList(
        requestParameters: PropertymappingsAllListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedPropertyMappingList> {
        const response = await this.propertymappingsAllListRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        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 = `/propertymappings/all/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * PropertyMapping Viewset
     */
    async propertymappingsAllRetrieveRaw(
        requestParameters: PropertymappingsAllRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PropertyMapping>> {
        const requestOptions = await this.propertymappingsAllRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PropertyMapping Viewset
     */
    async propertymappingsAllRetrieve(
        requestParameters: PropertymappingsAllRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PropertyMapping> {
        const response = await this.propertymappingsAllRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        const queryParameters: any = {};

        if (requestParameters["formatResult"] != null) {
            queryParameters["format_result"] = requestParameters["formatResult"];
        }

        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 = `/propertymappings/all/{pm_uuid}/test/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * Test Property Mapping
     */
    async propertymappingsAllTestCreateRaw(
        requestParameters: PropertymappingsAllTestCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PropertyMappingTestResult>> {
        const requestOptions =
            await this.propertymappingsAllTestCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Test Property Mapping
     */
    async propertymappingsAllTestCreate(
        requestParameters: PropertymappingsAllTestCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PropertyMappingTestResult> {
        const response = await this.propertymappingsAllTestCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

    /**
     * Creates request options for propertymappingsAllTypesList without sending the request
     */
    async propertymappingsAllTypesListRequestOpts(): 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 = `/propertymappings/all/types/`;

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

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

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

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

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

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

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

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

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

        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 = `/propertymappings/notification/`;

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

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationCreateRaw(
        requestParameters: PropertymappingsNotificationCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<NotificationWebhookMapping>> {
        const requestOptions =
            await this.propertymappingsNotificationCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationCreate(
        requestParameters: PropertymappingsNotificationCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<NotificationWebhookMapping> {
        const response = await this.propertymappingsNotificationCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/notification/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationDestroyRaw(
        requestParameters: PropertymappingsNotificationDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsNotificationDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationDestroy(
        requestParameters: PropertymappingsNotificationDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsNotificationDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for propertymappingsNotificationList without sending the request
     */
    async propertymappingsNotificationListRequestOpts(
        requestParameters: PropertymappingsNotificationListRequest,
    ): 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 = `/propertymappings/notification/`;

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

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationListRaw(
        requestParameters: PropertymappingsNotificationListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedNotificationWebhookMappingList>> {
        const requestOptions =
            await this.propertymappingsNotificationListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationList(
        requestParameters: PropertymappingsNotificationListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedNotificationWebhookMappingList> {
        const response = await this.propertymappingsNotificationListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/notification/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationPartialUpdateRaw(
        requestParameters: PropertymappingsNotificationPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<NotificationWebhookMapping>> {
        const requestOptions =
            await this.propertymappingsNotificationPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationPartialUpdate(
        requestParameters: PropertymappingsNotificationPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<NotificationWebhookMapping> {
        const response = await this.propertymappingsNotificationPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/notification/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationRetrieveRaw(
        requestParameters: PropertymappingsNotificationRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<NotificationWebhookMapping>> {
        const requestOptions =
            await this.propertymappingsNotificationRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationRetrieve(
        requestParameters: PropertymappingsNotificationRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<NotificationWebhookMapping> {
        const response = await this.propertymappingsNotificationRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/notification/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationUpdateRaw(
        requestParameters: PropertymappingsNotificationUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<NotificationWebhookMapping>> {
        const requestOptions =
            await this.propertymappingsNotificationUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * NotificationWebhookMapping Viewset
     */
    async propertymappingsNotificationUpdate(
        requestParameters: PropertymappingsNotificationUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<NotificationWebhookMapping> {
        const response = await this.propertymappingsNotificationUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

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

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

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

        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 = `/propertymappings/provider/google_workspace/`;

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

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspaceCreateRaw(
        requestParameters: PropertymappingsProviderGoogleWorkspaceCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<GoogleWorkspaceProviderMapping>> {
        const requestOptions =
            await this.propertymappingsProviderGoogleWorkspaceCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspaceCreate(
        requestParameters: PropertymappingsProviderGoogleWorkspaceCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<GoogleWorkspaceProviderMapping> {
        const response = await this.propertymappingsProviderGoogleWorkspaceCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/google_workspace/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspaceDestroyRaw(
        requestParameters: PropertymappingsProviderGoogleWorkspaceDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsProviderGoogleWorkspaceDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspaceDestroy(
        requestParameters: PropertymappingsProviderGoogleWorkspaceDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsProviderGoogleWorkspaceDestroyRaw(
            requestParameters,
            initOverrides,
        );
    }

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

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

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

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

        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 = `/propertymappings/provider/google_workspace/`;

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

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspaceListRaw(
        requestParameters: PropertymappingsProviderGoogleWorkspaceListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedGoogleWorkspaceProviderMappingList>> {
        const requestOptions =
            await this.propertymappingsProviderGoogleWorkspaceListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspaceList(
        requestParameters: PropertymappingsProviderGoogleWorkspaceListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedGoogleWorkspaceProviderMappingList> {
        const response = await this.propertymappingsProviderGoogleWorkspaceListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/google_workspace/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspacePartialUpdateRaw(
        requestParameters: PropertymappingsProviderGoogleWorkspacePartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<GoogleWorkspaceProviderMapping>> {
        const requestOptions =
            await this.propertymappingsProviderGoogleWorkspacePartialUpdateRequestOpts(
                requestParameters,
            );
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspacePartialUpdate(
        requestParameters: PropertymappingsProviderGoogleWorkspacePartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<GoogleWorkspaceProviderMapping> {
        const response = await this.propertymappingsProviderGoogleWorkspacePartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/google_workspace/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspaceRetrieveRaw(
        requestParameters: PropertymappingsProviderGoogleWorkspaceRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<GoogleWorkspaceProviderMapping>> {
        const requestOptions =
            await this.propertymappingsProviderGoogleWorkspaceRetrieveRequestOpts(
                requestParameters,
            );
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspaceRetrieve(
        requestParameters: PropertymappingsProviderGoogleWorkspaceRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<GoogleWorkspaceProviderMapping> {
        const response = await this.propertymappingsProviderGoogleWorkspaceRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/provider/google_workspace/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspaceUpdateRaw(
        requestParameters: PropertymappingsProviderGoogleWorkspaceUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<GoogleWorkspaceProviderMapping>> {
        const requestOptions =
            await this.propertymappingsProviderGoogleWorkspaceUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * GoogleWorkspaceProviderMapping Viewset
     */
    async propertymappingsProviderGoogleWorkspaceUpdate(
        requestParameters: PropertymappingsProviderGoogleWorkspaceUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<GoogleWorkspaceProviderMapping> {
        const response = await this.propertymappingsProviderGoogleWorkspaceUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/google_workspace/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/provider/microsoft_entra/`;

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

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraCreateRaw(
        requestParameters: PropertymappingsProviderMicrosoftEntraCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<MicrosoftEntraProviderMapping>> {
        const requestOptions =
            await this.propertymappingsProviderMicrosoftEntraCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraCreate(
        requestParameters: PropertymappingsProviderMicrosoftEntraCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<MicrosoftEntraProviderMapping> {
        const response = await this.propertymappingsProviderMicrosoftEntraCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/microsoft_entra/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraDestroyRaw(
        requestParameters: PropertymappingsProviderMicrosoftEntraDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsProviderMicrosoftEntraDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraDestroy(
        requestParameters: PropertymappingsProviderMicrosoftEntraDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsProviderMicrosoftEntraDestroyRaw(
            requestParameters,
            initOverrides,
        );
    }

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

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

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

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

        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 = `/propertymappings/provider/microsoft_entra/`;

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

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraListRaw(
        requestParameters: PropertymappingsProviderMicrosoftEntraListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedMicrosoftEntraProviderMappingList>> {
        const requestOptions =
            await this.propertymappingsProviderMicrosoftEntraListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraList(
        requestParameters: PropertymappingsProviderMicrosoftEntraListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedMicrosoftEntraProviderMappingList> {
        const response = await this.propertymappingsProviderMicrosoftEntraListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/microsoft_entra/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraPartialUpdateRaw(
        requestParameters: PropertymappingsProviderMicrosoftEntraPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<MicrosoftEntraProviderMapping>> {
        const requestOptions =
            await this.propertymappingsProviderMicrosoftEntraPartialUpdateRequestOpts(
                requestParameters,
            );
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraPartialUpdate(
        requestParameters: PropertymappingsProviderMicrosoftEntraPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<MicrosoftEntraProviderMapping> {
        const response = await this.propertymappingsProviderMicrosoftEntraPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/microsoft_entra/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraRetrieveRaw(
        requestParameters: PropertymappingsProviderMicrosoftEntraRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<MicrosoftEntraProviderMapping>> {
        const requestOptions =
            await this.propertymappingsProviderMicrosoftEntraRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraRetrieve(
        requestParameters: PropertymappingsProviderMicrosoftEntraRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<MicrosoftEntraProviderMapping> {
        const response = await this.propertymappingsProviderMicrosoftEntraRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/provider/microsoft_entra/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraUpdateRaw(
        requestParameters: PropertymappingsProviderMicrosoftEntraUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<MicrosoftEntraProviderMapping>> {
        const requestOptions =
            await this.propertymappingsProviderMicrosoftEntraUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * MicrosoftEntraProviderMapping Viewset
     */
    async propertymappingsProviderMicrosoftEntraUpdate(
        requestParameters: PropertymappingsProviderMicrosoftEntraUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<MicrosoftEntraProviderMapping> {
        const response = await this.propertymappingsProviderMicrosoftEntraUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/microsoft_entra/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/provider/rac/`;

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

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacCreateRaw(
        requestParameters: PropertymappingsProviderRacCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<RACPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderRacCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacCreate(
        requestParameters: PropertymappingsProviderRacCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<RACPropertyMapping> {
        const response = await this.propertymappingsProviderRacCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/rac/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacDestroyRaw(
        requestParameters: PropertymappingsProviderRacDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsProviderRacDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacDestroy(
        requestParameters: PropertymappingsProviderRacDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsProviderRacDestroyRaw(requestParameters, initOverrides);
    }

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

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

        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 = `/propertymappings/provider/rac/`;

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

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacListRaw(
        requestParameters: PropertymappingsProviderRacListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedRACPropertyMappingList>> {
        const requestOptions =
            await this.propertymappingsProviderRacListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacList(
        requestParameters: PropertymappingsProviderRacListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedRACPropertyMappingList> {
        const response = await this.propertymappingsProviderRacListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/rac/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacPartialUpdateRaw(
        requestParameters: PropertymappingsProviderRacPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<RACPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderRacPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacPartialUpdate(
        requestParameters: PropertymappingsProviderRacPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<RACPropertyMapping> {
        const response = await this.propertymappingsProviderRacPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/rac/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacRetrieveRaw(
        requestParameters: PropertymappingsProviderRacRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<RACPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderRacRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacRetrieve(
        requestParameters: PropertymappingsProviderRacRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<RACPropertyMapping> {
        const response = await this.propertymappingsProviderRacRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/provider/rac/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacUpdateRaw(
        requestParameters: PropertymappingsProviderRacUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<RACPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderRacUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * RACPropertyMapping Viewset
     */
    async propertymappingsProviderRacUpdate(
        requestParameters: PropertymappingsProviderRacUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<RACPropertyMapping> {
        const response = await this.propertymappingsProviderRacUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/rac/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/provider/radius/`;

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

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusCreateRaw(
        requestParameters: PropertymappingsProviderRadiusCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<RadiusProviderPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderRadiusCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusCreate(
        requestParameters: PropertymappingsProviderRadiusCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<RadiusProviderPropertyMapping> {
        const response = await this.propertymappingsProviderRadiusCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/radius/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusDestroyRaw(
        requestParameters: PropertymappingsProviderRadiusDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsProviderRadiusDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusDestroy(
        requestParameters: PropertymappingsProviderRadiusDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsProviderRadiusDestroyRaw(requestParameters, initOverrides);
    }

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

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

        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 = `/propertymappings/provider/radius/`;

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

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusListRaw(
        requestParameters: PropertymappingsProviderRadiusListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedRadiusProviderPropertyMappingList>> {
        const requestOptions =
            await this.propertymappingsProviderRadiusListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusList(
        requestParameters: PropertymappingsProviderRadiusListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedRadiusProviderPropertyMappingList> {
        const response = await this.propertymappingsProviderRadiusListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/radius/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusPartialUpdateRaw(
        requestParameters: PropertymappingsProviderRadiusPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<RadiusProviderPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderRadiusPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusPartialUpdate(
        requestParameters: PropertymappingsProviderRadiusPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<RadiusProviderPropertyMapping> {
        const response = await this.propertymappingsProviderRadiusPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/radius/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusRetrieveRaw(
        requestParameters: PropertymappingsProviderRadiusRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<RadiusProviderPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderRadiusRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusRetrieve(
        requestParameters: PropertymappingsProviderRadiusRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<RadiusProviderPropertyMapping> {
        const response = await this.propertymappingsProviderRadiusRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/provider/radius/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusUpdateRaw(
        requestParameters: PropertymappingsProviderRadiusUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<RadiusProviderPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderRadiusUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * RadiusProviderPropertyMapping Viewset
     */
    async propertymappingsProviderRadiusUpdate(
        requestParameters: PropertymappingsProviderRadiusUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<RadiusProviderPropertyMapping> {
        const response = await this.propertymappingsProviderRadiusUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/radius/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/provider/saml/`;

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

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlCreateRaw(
        requestParameters: PropertymappingsProviderSamlCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SAMLPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderSamlCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlCreate(
        requestParameters: PropertymappingsProviderSamlCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SAMLPropertyMapping> {
        const response = await this.propertymappingsProviderSamlCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/saml/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlDestroyRaw(
        requestParameters: PropertymappingsProviderSamlDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsProviderSamlDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlDestroy(
        requestParameters: PropertymappingsProviderSamlDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsProviderSamlDestroyRaw(requestParameters, initOverrides);
    }

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

        if (requestParameters["friendlyName"] != null) {
            queryParameters["friendly_name"] = requestParameters["friendlyName"];
        }

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

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

        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 = `/propertymappings/provider/saml/`;

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

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlListRaw(
        requestParameters: PropertymappingsProviderSamlListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedSAMLPropertyMappingList>> {
        const requestOptions =
            await this.propertymappingsProviderSamlListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlList(
        requestParameters: PropertymappingsProviderSamlListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedSAMLPropertyMappingList> {
        const response = await this.propertymappingsProviderSamlListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/saml/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlPartialUpdateRaw(
        requestParameters: PropertymappingsProviderSamlPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SAMLPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderSamlPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlPartialUpdate(
        requestParameters: PropertymappingsProviderSamlPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SAMLPropertyMapping> {
        const response = await this.propertymappingsProviderSamlPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/saml/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlRetrieveRaw(
        requestParameters: PropertymappingsProviderSamlRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SAMLPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderSamlRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlRetrieve(
        requestParameters: PropertymappingsProviderSamlRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SAMLPropertyMapping> {
        const response = await this.propertymappingsProviderSamlRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/provider/saml/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlUpdateRaw(
        requestParameters: PropertymappingsProviderSamlUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SAMLPropertyMapping>> {
        const requestOptions =
            await this.propertymappingsProviderSamlUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SAMLPropertyMapping Viewset
     */
    async propertymappingsProviderSamlUpdate(
        requestParameters: PropertymappingsProviderSamlUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SAMLPropertyMapping> {
        const response = await this.propertymappingsProviderSamlUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/saml/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/provider/scim/`;

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

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimCreateRaw(
        requestParameters: PropertymappingsProviderScimCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SCIMMapping>> {
        const requestOptions =
            await this.propertymappingsProviderScimCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimCreate(
        requestParameters: PropertymappingsProviderScimCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SCIMMapping> {
        const response = await this.propertymappingsProviderScimCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/scim/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimDestroyRaw(
        requestParameters: PropertymappingsProviderScimDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsProviderScimDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimDestroy(
        requestParameters: PropertymappingsProviderScimDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsProviderScimDestroyRaw(requestParameters, initOverrides);
    }

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

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

        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 = `/propertymappings/provider/scim/`;

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

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimListRaw(
        requestParameters: PropertymappingsProviderScimListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedSCIMMappingList>> {
        const requestOptions =
            await this.propertymappingsProviderScimListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimList(
        requestParameters: PropertymappingsProviderScimListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedSCIMMappingList> {
        const response = await this.propertymappingsProviderScimListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/scim/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimPartialUpdateRaw(
        requestParameters: PropertymappingsProviderScimPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SCIMMapping>> {
        const requestOptions =
            await this.propertymappingsProviderScimPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimPartialUpdate(
        requestParameters: PropertymappingsProviderScimPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SCIMMapping> {
        const response = await this.propertymappingsProviderScimPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/scim/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimRetrieveRaw(
        requestParameters: PropertymappingsProviderScimRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SCIMMapping>> {
        const requestOptions =
            await this.propertymappingsProviderScimRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimRetrieve(
        requestParameters: PropertymappingsProviderScimRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SCIMMapping> {
        const response = await this.propertymappingsProviderScimRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/provider/scim/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimUpdateRaw(
        requestParameters: PropertymappingsProviderScimUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SCIMMapping>> {
        const requestOptions =
            await this.propertymappingsProviderScimUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SCIMMapping Viewset
     */
    async propertymappingsProviderScimUpdate(
        requestParameters: PropertymappingsProviderScimUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SCIMMapping> {
        const response = await this.propertymappingsProviderScimUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/scim/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/provider/scope/`;

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

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopeCreateRaw(
        requestParameters: PropertymappingsProviderScopeCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<ScopeMapping>> {
        const requestOptions =
            await this.propertymappingsProviderScopeCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopeCreate(
        requestParameters: PropertymappingsProviderScopeCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<ScopeMapping> {
        const response = await this.propertymappingsProviderScopeCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/scope/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopeDestroyRaw(
        requestParameters: PropertymappingsProviderScopeDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsProviderScopeDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopeDestroy(
        requestParameters: PropertymappingsProviderScopeDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsProviderScopeDestroyRaw(requestParameters, initOverrides);
    }

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

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

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

        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 = `/propertymappings/provider/scope/`;

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

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopeListRaw(
        requestParameters: PropertymappingsProviderScopeListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedScopeMappingList>> {
        const requestOptions =
            await this.propertymappingsProviderScopeListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopeList(
        requestParameters: PropertymappingsProviderScopeListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedScopeMappingList> {
        const response = await this.propertymappingsProviderScopeListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/scope/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopePartialUpdateRaw(
        requestParameters: PropertymappingsProviderScopePartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<ScopeMapping>> {
        const requestOptions =
            await this.propertymappingsProviderScopePartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopePartialUpdate(
        requestParameters: PropertymappingsProviderScopePartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<ScopeMapping> {
        const response = await this.propertymappingsProviderScopePartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/scope/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopeRetrieveRaw(
        requestParameters: PropertymappingsProviderScopeRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<ScopeMapping>> {
        const requestOptions =
            await this.propertymappingsProviderScopeRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopeRetrieve(
        requestParameters: PropertymappingsProviderScopeRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<ScopeMapping> {
        const response = await this.propertymappingsProviderScopeRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/provider/scope/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopeUpdateRaw(
        requestParameters: PropertymappingsProviderScopeUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<ScopeMapping>> {
        const requestOptions =
            await this.propertymappingsProviderScopeUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * ScopeMapping Viewset
     */
    async propertymappingsProviderScopeUpdate(
        requestParameters: PropertymappingsProviderScopeUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<ScopeMapping> {
        const response = await this.propertymappingsProviderScopeUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/provider/scope/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/source/kerberos/`;

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

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosCreateRaw(
        requestParameters: PropertymappingsSourceKerberosCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<KerberosSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceKerberosCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosCreate(
        requestParameters: PropertymappingsSourceKerberosCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<KerberosSourcePropertyMapping> {
        const response = await this.propertymappingsSourceKerberosCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/kerberos/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosDestroyRaw(
        requestParameters: PropertymappingsSourceKerberosDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsSourceKerberosDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosDestroy(
        requestParameters: PropertymappingsSourceKerberosDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsSourceKerberosDestroyRaw(requestParameters, initOverrides);
    }

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

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

        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 = `/propertymappings/source/kerberos/`;

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

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosListRaw(
        requestParameters: PropertymappingsSourceKerberosListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedKerberosSourcePropertyMappingList>> {
        const requestOptions =
            await this.propertymappingsSourceKerberosListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosList(
        requestParameters: PropertymappingsSourceKerberosListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedKerberosSourcePropertyMappingList> {
        const response = await this.propertymappingsSourceKerberosListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/kerberos/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosPartialUpdateRaw(
        requestParameters: PropertymappingsSourceKerberosPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<KerberosSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceKerberosPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosPartialUpdate(
        requestParameters: PropertymappingsSourceKerberosPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<KerberosSourcePropertyMapping> {
        const response = await this.propertymappingsSourceKerberosPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/kerberos/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosRetrieveRaw(
        requestParameters: PropertymappingsSourceKerberosRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<KerberosSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceKerberosRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosRetrieve(
        requestParameters: PropertymappingsSourceKerberosRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<KerberosSourcePropertyMapping> {
        const response = await this.propertymappingsSourceKerberosRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/source/kerberos/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosUpdateRaw(
        requestParameters: PropertymappingsSourceKerberosUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<KerberosSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceKerberosUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * KerberosSource PropertyMapping Viewset
     */
    async propertymappingsSourceKerberosUpdate(
        requestParameters: PropertymappingsSourceKerberosUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<KerberosSourcePropertyMapping> {
        const response = await this.propertymappingsSourceKerberosUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/kerberos/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/source/ldap/`;

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

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapCreateRaw(
        requestParameters: PropertymappingsSourceLdapCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<LDAPSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceLdapCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapCreate(
        requestParameters: PropertymappingsSourceLdapCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<LDAPSourcePropertyMapping> {
        const response = await this.propertymappingsSourceLdapCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/ldap/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapDestroyRaw(
        requestParameters: PropertymappingsSourceLdapDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsSourceLdapDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapDestroy(
        requestParameters: PropertymappingsSourceLdapDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsSourceLdapDestroyRaw(requestParameters, initOverrides);
    }

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

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

        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 = `/propertymappings/source/ldap/`;

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

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapListRaw(
        requestParameters: PropertymappingsSourceLdapListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedLDAPSourcePropertyMappingList>> {
        const requestOptions =
            await this.propertymappingsSourceLdapListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapList(
        requestParameters: PropertymappingsSourceLdapListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedLDAPSourcePropertyMappingList> {
        const response = await this.propertymappingsSourceLdapListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/ldap/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapPartialUpdateRaw(
        requestParameters: PropertymappingsSourceLdapPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<LDAPSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceLdapPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapPartialUpdate(
        requestParameters: PropertymappingsSourceLdapPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<LDAPSourcePropertyMapping> {
        const response = await this.propertymappingsSourceLdapPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/ldap/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapRetrieveRaw(
        requestParameters: PropertymappingsSourceLdapRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<LDAPSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceLdapRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapRetrieve(
        requestParameters: PropertymappingsSourceLdapRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<LDAPSourcePropertyMapping> {
        const response = await this.propertymappingsSourceLdapRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/source/ldap/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapUpdateRaw(
        requestParameters: PropertymappingsSourceLdapUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<LDAPSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceLdapUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * LDAP PropertyMapping Viewset
     */
    async propertymappingsSourceLdapUpdate(
        requestParameters: PropertymappingsSourceLdapUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<LDAPSourcePropertyMapping> {
        const response = await this.propertymappingsSourceLdapUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/ldap/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/source/oauth/`;

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

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthCreateRaw(
        requestParameters: PropertymappingsSourceOauthCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<OAuthSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceOauthCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthCreate(
        requestParameters: PropertymappingsSourceOauthCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<OAuthSourcePropertyMapping> {
        const response = await this.propertymappingsSourceOauthCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/oauth/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthDestroyRaw(
        requestParameters: PropertymappingsSourceOauthDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsSourceOauthDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthDestroy(
        requestParameters: PropertymappingsSourceOauthDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsSourceOauthDestroyRaw(requestParameters, initOverrides);
    }

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

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

        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 = `/propertymappings/source/oauth/`;

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

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthListRaw(
        requestParameters: PropertymappingsSourceOauthListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedOAuthSourcePropertyMappingList>> {
        const requestOptions =
            await this.propertymappingsSourceOauthListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthList(
        requestParameters: PropertymappingsSourceOauthListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedOAuthSourcePropertyMappingList> {
        const response = await this.propertymappingsSourceOauthListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/oauth/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthPartialUpdateRaw(
        requestParameters: PropertymappingsSourceOauthPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<OAuthSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceOauthPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthPartialUpdate(
        requestParameters: PropertymappingsSourceOauthPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<OAuthSourcePropertyMapping> {
        const response = await this.propertymappingsSourceOauthPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/oauth/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthRetrieveRaw(
        requestParameters: PropertymappingsSourceOauthRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<OAuthSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceOauthRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthRetrieve(
        requestParameters: PropertymappingsSourceOauthRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<OAuthSourcePropertyMapping> {
        const response = await this.propertymappingsSourceOauthRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/source/oauth/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthUpdateRaw(
        requestParameters: PropertymappingsSourceOauthUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<OAuthSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceOauthUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * OAuthSourcePropertyMapping Viewset
     */
    async propertymappingsSourceOauthUpdate(
        requestParameters: PropertymappingsSourceOauthUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<OAuthSourcePropertyMapping> {
        const response = await this.propertymappingsSourceOauthUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/oauth/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/source/plex/`;

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

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexCreateRaw(
        requestParameters: PropertymappingsSourcePlexCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PlexSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourcePlexCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexCreate(
        requestParameters: PropertymappingsSourcePlexCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PlexSourcePropertyMapping> {
        const response = await this.propertymappingsSourcePlexCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/plex/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexDestroyRaw(
        requestParameters: PropertymappingsSourcePlexDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsSourcePlexDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexDestroy(
        requestParameters: PropertymappingsSourcePlexDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsSourcePlexDestroyRaw(requestParameters, initOverrides);
    }

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

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

        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 = `/propertymappings/source/plex/`;

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

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexListRaw(
        requestParameters: PropertymappingsSourcePlexListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedPlexSourcePropertyMappingList>> {
        const requestOptions =
            await this.propertymappingsSourcePlexListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexList(
        requestParameters: PropertymappingsSourcePlexListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedPlexSourcePropertyMappingList> {
        const response = await this.propertymappingsSourcePlexListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/plex/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexPartialUpdateRaw(
        requestParameters: PropertymappingsSourcePlexPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PlexSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourcePlexPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexPartialUpdate(
        requestParameters: PropertymappingsSourcePlexPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PlexSourcePropertyMapping> {
        const response = await this.propertymappingsSourcePlexPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/plex/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexRetrieveRaw(
        requestParameters: PropertymappingsSourcePlexRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PlexSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourcePlexRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexRetrieve(
        requestParameters: PropertymappingsSourcePlexRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PlexSourcePropertyMapping> {
        const response = await this.propertymappingsSourcePlexRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/source/plex/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexUpdateRaw(
        requestParameters: PropertymappingsSourcePlexUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PlexSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourcePlexUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * PlexSourcePropertyMapping Viewset
     */
    async propertymappingsSourcePlexUpdate(
        requestParameters: PropertymappingsSourcePlexUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PlexSourcePropertyMapping> {
        const response = await this.propertymappingsSourcePlexUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/plex/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/source/saml/`;

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

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlCreateRaw(
        requestParameters: PropertymappingsSourceSamlCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SAMLSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceSamlCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlCreate(
        requestParameters: PropertymappingsSourceSamlCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SAMLSourcePropertyMapping> {
        const response = await this.propertymappingsSourceSamlCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/saml/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlDestroyRaw(
        requestParameters: PropertymappingsSourceSamlDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsSourceSamlDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlDestroy(
        requestParameters: PropertymappingsSourceSamlDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsSourceSamlDestroyRaw(requestParameters, initOverrides);
    }

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

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

        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 = `/propertymappings/source/saml/`;

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

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlListRaw(
        requestParameters: PropertymappingsSourceSamlListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedSAMLSourcePropertyMappingList>> {
        const requestOptions =
            await this.propertymappingsSourceSamlListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlList(
        requestParameters: PropertymappingsSourceSamlListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedSAMLSourcePropertyMappingList> {
        const response = await this.propertymappingsSourceSamlListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/saml/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlPartialUpdateRaw(
        requestParameters: PropertymappingsSourceSamlPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SAMLSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceSamlPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlPartialUpdate(
        requestParameters: PropertymappingsSourceSamlPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SAMLSourcePropertyMapping> {
        const response = await this.propertymappingsSourceSamlPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/saml/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlRetrieveRaw(
        requestParameters: PropertymappingsSourceSamlRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SAMLSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceSamlRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlRetrieve(
        requestParameters: PropertymappingsSourceSamlRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SAMLSourcePropertyMapping> {
        const response = await this.propertymappingsSourceSamlRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/source/saml/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlUpdateRaw(
        requestParameters: PropertymappingsSourceSamlUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SAMLSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceSamlUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SAMLSourcePropertyMapping Viewset
     */
    async propertymappingsSourceSamlUpdate(
        requestParameters: PropertymappingsSourceSamlUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SAMLSourcePropertyMapping> {
        const response = await this.propertymappingsSourceSamlUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/saml/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/source/scim/`;

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

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimCreateRaw(
        requestParameters: PropertymappingsSourceScimCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SCIMSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceScimCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimCreate(
        requestParameters: PropertymappingsSourceScimCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SCIMSourcePropertyMapping> {
        const response = await this.propertymappingsSourceScimCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/scim/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimDestroyRaw(
        requestParameters: PropertymappingsSourceScimDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsSourceScimDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimDestroy(
        requestParameters: PropertymappingsSourceScimDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsSourceScimDestroyRaw(requestParameters, initOverrides);
    }

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

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

        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 = `/propertymappings/source/scim/`;

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

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimListRaw(
        requestParameters: PropertymappingsSourceScimListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedSCIMSourcePropertyMappingList>> {
        const requestOptions =
            await this.propertymappingsSourceScimListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimList(
        requestParameters: PropertymappingsSourceScimListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedSCIMSourcePropertyMappingList> {
        const response = await this.propertymappingsSourceScimListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/scim/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimPartialUpdateRaw(
        requestParameters: PropertymappingsSourceScimPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SCIMSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceScimPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimPartialUpdate(
        requestParameters: PropertymappingsSourceScimPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SCIMSourcePropertyMapping> {
        const response = await this.propertymappingsSourceScimPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/scim/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimRetrieveRaw(
        requestParameters: PropertymappingsSourceScimRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SCIMSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceScimRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimRetrieve(
        requestParameters: PropertymappingsSourceScimRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SCIMSourcePropertyMapping> {
        const response = await this.propertymappingsSourceScimRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/source/scim/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimUpdateRaw(
        requestParameters: PropertymappingsSourceScimUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<SCIMSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceScimUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * SCIMSourcePropertyMapping Viewset
     */
    async propertymappingsSourceScimUpdate(
        requestParameters: PropertymappingsSourceScimUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<SCIMSourcePropertyMapping> {
        const response = await this.propertymappingsSourceScimUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/scim/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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

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

        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 = `/propertymappings/source/telegram/`;

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

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramCreateRaw(
        requestParameters: PropertymappingsSourceTelegramCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<TelegramSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceTelegramCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramCreate(
        requestParameters: PropertymappingsSourceTelegramCreateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<TelegramSourcePropertyMapping> {
        const response = await this.propertymappingsSourceTelegramCreateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/telegram/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramDestroyRaw(
        requestParameters: PropertymappingsSourceTelegramDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<void>> {
        const requestOptions =
            await this.propertymappingsSourceTelegramDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramDestroy(
        requestParameters: PropertymappingsSourceTelegramDestroyRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<void> {
        await this.propertymappingsSourceTelegramDestroyRaw(requestParameters, initOverrides);
    }

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

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

        if (requestParameters["managedIsnull"] != null) {
            queryParameters["managed__isnull"] = requestParameters["managedIsnull"];
        }

        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 = `/propertymappings/source/telegram/`;

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

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramListRaw(
        requestParameters: PropertymappingsSourceTelegramListRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<PaginatedTelegramSourcePropertyMappingList>> {
        const requestOptions =
            await this.propertymappingsSourceTelegramListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramList(
        requestParameters: PropertymappingsSourceTelegramListRequest = {},
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<PaginatedTelegramSourcePropertyMappingList> {
        const response = await this.propertymappingsSourceTelegramListRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/telegram/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramPartialUpdateRaw(
        requestParameters: PropertymappingsSourceTelegramPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<TelegramSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceTelegramPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramPartialUpdate(
        requestParameters: PropertymappingsSourceTelegramPartialUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<TelegramSourcePropertyMapping> {
        const response = await this.propertymappingsSourceTelegramPartialUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/telegram/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramRetrieveRaw(
        requestParameters: PropertymappingsSourceTelegramRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<TelegramSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceTelegramRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramRetrieve(
        requestParameters: PropertymappingsSourceTelegramRetrieveRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<TelegramSourcePropertyMapping> {
        const response = await this.propertymappingsSourceTelegramRetrieveRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

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

        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 = `/propertymappings/source/telegram/{pm_uuid}/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramUpdateRaw(
        requestParameters: PropertymappingsSourceTelegramUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<runtime.ApiResponse<TelegramSourcePropertyMapping>> {
        const requestOptions =
            await this.propertymappingsSourceTelegramUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * TelegramSourcePropertyMapping Viewset
     */
    async propertymappingsSourceTelegramUpdate(
        requestParameters: PropertymappingsSourceTelegramUpdateRequest,
        initOverrides?: RequestInit | runtime.InitOverrideFunction,
    ): Promise<TelegramSourcePropertyMapping> {
        const response = await this.propertymappingsSourceTelegramUpdateRaw(
            requestParameters,
            initOverrides,
        );
        return await response.value();
    }

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

        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 = `/propertymappings/source/telegram/{pm_uuid}/used_by/`;
        urlPath = urlPath.replace(
            `{${"pm_uuid"}}`,
            encodeURIComponent(String(requestParameters["pmUuid"])),
        );

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

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