/* tslint:disable */
/* eslint-disable */
/**
 * authentik
 * Making authentication simple.
 *
 * The version of the OpenAPI document: 2025.6.3
 * Contact: hello@goauthentik.io
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */


import * as runtime from '../runtime';
import type {
  FilePathRequest,
  GenericError,
  GroupKerberosSourceConnection,
  GroupKerberosSourceConnectionRequest,
  GroupLDAPSourceConnection,
  GroupLDAPSourceConnectionRequest,
  GroupOAuthSourceConnection,
  GroupOAuthSourceConnectionRequest,
  GroupPlexSourceConnection,
  GroupPlexSourceConnectionRequest,
  GroupSAMLSourceConnection,
  GroupSAMLSourceConnectionRequest,
  GroupSourceConnection,
  GroupSourceConnectionRequest,
  KerberosSource,
  KerberosSourceRequest,
  KerberosSyncStatus,
  LDAPDebug,
  LDAPSource,
  LDAPSourceRequest,
  OAuthSource,
  OAuthSourceRequest,
  PaginatedGroupKerberosSourceConnectionList,
  PaginatedGroupLDAPSourceConnectionList,
  PaginatedGroupOAuthSourceConnectionList,
  PaginatedGroupPlexSourceConnectionList,
  PaginatedGroupSAMLSourceConnectionList,
  PaginatedGroupSourceConnectionList,
  PaginatedKerberosSourceList,
  PaginatedLDAPSourceList,
  PaginatedOAuthSourceList,
  PaginatedPlexSourceList,
  PaginatedSAMLSourceList,
  PaginatedSCIMSourceGroupList,
  PaginatedSCIMSourceList,
  PaginatedSCIMSourceUserList,
  PaginatedSourceList,
  PaginatedUserKerberosSourceConnectionList,
  PaginatedUserLDAPSourceConnectionList,
  PaginatedUserOAuthSourceConnectionList,
  PaginatedUserPlexSourceConnectionList,
  PaginatedUserSAMLSourceConnectionList,
  PaginatedUserSourceConnectionList,
  PatchedGroupKerberosSourceConnectionRequest,
  PatchedGroupLDAPSourceConnectionRequest,
  PatchedGroupOAuthSourceConnectionRequest,
  PatchedGroupPlexSourceConnectionRequest,
  PatchedGroupSAMLSourceConnectionRequest,
  PatchedGroupSourceConnectionRequest,
  PatchedKerberosSourceRequest,
  PatchedLDAPSourceRequest,
  PatchedOAuthSourceRequest,
  PatchedPlexSourceRequest,
  PatchedSAMLSourceRequest,
  PatchedSCIMSourceGroupRequest,
  PatchedSCIMSourceRequest,
  PatchedSCIMSourceUserRequest,
  PatchedUserKerberosSourceConnectionRequest,
  PatchedUserLDAPSourceConnectionRequest,
  PatchedUserOAuthSourceConnectionRequest,
  PatchedUserPlexSourceConnectionRequest,
  PatchedUserSAMLSourceConnectionRequest,
  PatchedUserSourceConnectionRequest,
  PlexSource,
  PlexSourceRequest,
  PlexTokenRedeemRequest,
  RedirectChallenge,
  SAMLMetadata,
  SAMLSource,
  SAMLSourceRequest,
  SCIMSource,
  SCIMSourceGroup,
  SCIMSourceGroupRequest,
  SCIMSourceRequest,
  SCIMSourceUser,
  SCIMSourceUserRequest,
  Source,
  SourceType,
  SyncStatus,
  TypeCreate,
  UsedBy,
  UserKerberosSourceConnection,
  UserKerberosSourceConnectionRequest,
  UserLDAPSourceConnection,
  UserLDAPSourceConnectionRequest,
  UserOAuthSourceConnection,
  UserOAuthSourceConnectionRequest,
  UserPlexSourceConnection,
  UserPlexSourceConnectionRequest,
  UserSAMLSourceConnection,
  UserSAMLSourceConnectionRequest,
  UserSetting,
  UserSourceConnection,
  UserSourceConnectionRequest,
  ValidationError,
} from '../models/index';
import {
    FilePathRequestFromJSON,
    FilePathRequestToJSON,
    GenericErrorFromJSON,
    GenericErrorToJSON,
    GroupKerberosSourceConnectionFromJSON,
    GroupKerberosSourceConnectionToJSON,
    GroupKerberosSourceConnectionRequestFromJSON,
    GroupKerberosSourceConnectionRequestToJSON,
    GroupLDAPSourceConnectionFromJSON,
    GroupLDAPSourceConnectionToJSON,
    GroupLDAPSourceConnectionRequestFromJSON,
    GroupLDAPSourceConnectionRequestToJSON,
    GroupOAuthSourceConnectionFromJSON,
    GroupOAuthSourceConnectionToJSON,
    GroupOAuthSourceConnectionRequestFromJSON,
    GroupOAuthSourceConnectionRequestToJSON,
    GroupPlexSourceConnectionFromJSON,
    GroupPlexSourceConnectionToJSON,
    GroupPlexSourceConnectionRequestFromJSON,
    GroupPlexSourceConnectionRequestToJSON,
    GroupSAMLSourceConnectionFromJSON,
    GroupSAMLSourceConnectionToJSON,
    GroupSAMLSourceConnectionRequestFromJSON,
    GroupSAMLSourceConnectionRequestToJSON,
    GroupSourceConnectionFromJSON,
    GroupSourceConnectionToJSON,
    GroupSourceConnectionRequestFromJSON,
    GroupSourceConnectionRequestToJSON,
    KerberosSourceFromJSON,
    KerberosSourceToJSON,
    KerberosSourceRequestFromJSON,
    KerberosSourceRequestToJSON,
    KerberosSyncStatusFromJSON,
    KerberosSyncStatusToJSON,
    LDAPDebugFromJSON,
    LDAPDebugToJSON,
    LDAPSourceFromJSON,
    LDAPSourceToJSON,
    LDAPSourceRequestFromJSON,
    LDAPSourceRequestToJSON,
    OAuthSourceFromJSON,
    OAuthSourceToJSON,
    OAuthSourceRequestFromJSON,
    OAuthSourceRequestToJSON,
    PaginatedGroupKerberosSourceConnectionListFromJSON,
    PaginatedGroupKerberosSourceConnectionListToJSON,
    PaginatedGroupLDAPSourceConnectionListFromJSON,
    PaginatedGroupLDAPSourceConnectionListToJSON,
    PaginatedGroupOAuthSourceConnectionListFromJSON,
    PaginatedGroupOAuthSourceConnectionListToJSON,
    PaginatedGroupPlexSourceConnectionListFromJSON,
    PaginatedGroupPlexSourceConnectionListToJSON,
    PaginatedGroupSAMLSourceConnectionListFromJSON,
    PaginatedGroupSAMLSourceConnectionListToJSON,
    PaginatedGroupSourceConnectionListFromJSON,
    PaginatedGroupSourceConnectionListToJSON,
    PaginatedKerberosSourceListFromJSON,
    PaginatedKerberosSourceListToJSON,
    PaginatedLDAPSourceListFromJSON,
    PaginatedLDAPSourceListToJSON,
    PaginatedOAuthSourceListFromJSON,
    PaginatedOAuthSourceListToJSON,
    PaginatedPlexSourceListFromJSON,
    PaginatedPlexSourceListToJSON,
    PaginatedSAMLSourceListFromJSON,
    PaginatedSAMLSourceListToJSON,
    PaginatedSCIMSourceGroupListFromJSON,
    PaginatedSCIMSourceGroupListToJSON,
    PaginatedSCIMSourceListFromJSON,
    PaginatedSCIMSourceListToJSON,
    PaginatedSCIMSourceUserListFromJSON,
    PaginatedSCIMSourceUserListToJSON,
    PaginatedSourceListFromJSON,
    PaginatedSourceListToJSON,
    PaginatedUserKerberosSourceConnectionListFromJSON,
    PaginatedUserKerberosSourceConnectionListToJSON,
    PaginatedUserLDAPSourceConnectionListFromJSON,
    PaginatedUserLDAPSourceConnectionListToJSON,
    PaginatedUserOAuthSourceConnectionListFromJSON,
    PaginatedUserOAuthSourceConnectionListToJSON,
    PaginatedUserPlexSourceConnectionListFromJSON,
    PaginatedUserPlexSourceConnectionListToJSON,
    PaginatedUserSAMLSourceConnectionListFromJSON,
    PaginatedUserSAMLSourceConnectionListToJSON,
    PaginatedUserSourceConnectionListFromJSON,
    PaginatedUserSourceConnectionListToJSON,
    PatchedGroupKerberosSourceConnectionRequestFromJSON,
    PatchedGroupKerberosSourceConnectionRequestToJSON,
    PatchedGroupLDAPSourceConnectionRequestFromJSON,
    PatchedGroupLDAPSourceConnectionRequestToJSON,
    PatchedGroupOAuthSourceConnectionRequestFromJSON,
    PatchedGroupOAuthSourceConnectionRequestToJSON,
    PatchedGroupPlexSourceConnectionRequestFromJSON,
    PatchedGroupPlexSourceConnectionRequestToJSON,
    PatchedGroupSAMLSourceConnectionRequestFromJSON,
    PatchedGroupSAMLSourceConnectionRequestToJSON,
    PatchedGroupSourceConnectionRequestFromJSON,
    PatchedGroupSourceConnectionRequestToJSON,
    PatchedKerberosSourceRequestFromJSON,
    PatchedKerberosSourceRequestToJSON,
    PatchedLDAPSourceRequestFromJSON,
    PatchedLDAPSourceRequestToJSON,
    PatchedOAuthSourceRequestFromJSON,
    PatchedOAuthSourceRequestToJSON,
    PatchedPlexSourceRequestFromJSON,
    PatchedPlexSourceRequestToJSON,
    PatchedSAMLSourceRequestFromJSON,
    PatchedSAMLSourceRequestToJSON,
    PatchedSCIMSourceGroupRequestFromJSON,
    PatchedSCIMSourceGroupRequestToJSON,
    PatchedSCIMSourceRequestFromJSON,
    PatchedSCIMSourceRequestToJSON,
    PatchedSCIMSourceUserRequestFromJSON,
    PatchedSCIMSourceUserRequestToJSON,
    PatchedUserKerberosSourceConnectionRequestFromJSON,
    PatchedUserKerberosSourceConnectionRequestToJSON,
    PatchedUserLDAPSourceConnectionRequestFromJSON,
    PatchedUserLDAPSourceConnectionRequestToJSON,
    PatchedUserOAuthSourceConnectionRequestFromJSON,
    PatchedUserOAuthSourceConnectionRequestToJSON,
    PatchedUserPlexSourceConnectionRequestFromJSON,
    PatchedUserPlexSourceConnectionRequestToJSON,
    PatchedUserSAMLSourceConnectionRequestFromJSON,
    PatchedUserSAMLSourceConnectionRequestToJSON,
    PatchedUserSourceConnectionRequestFromJSON,
    PatchedUserSourceConnectionRequestToJSON,
    PlexSourceFromJSON,
    PlexSourceToJSON,
    PlexSourceRequestFromJSON,
    PlexSourceRequestToJSON,
    PlexTokenRedeemRequestFromJSON,
    PlexTokenRedeemRequestToJSON,
    RedirectChallengeFromJSON,
    RedirectChallengeToJSON,
    SAMLMetadataFromJSON,
    SAMLMetadataToJSON,
    SAMLSourceFromJSON,
    SAMLSourceToJSON,
    SAMLSourceRequestFromJSON,
    SAMLSourceRequestToJSON,
    SCIMSourceFromJSON,
    SCIMSourceToJSON,
    SCIMSourceGroupFromJSON,
    SCIMSourceGroupToJSON,
    SCIMSourceGroupRequestFromJSON,
    SCIMSourceGroupRequestToJSON,
    SCIMSourceRequestFromJSON,
    SCIMSourceRequestToJSON,
    SCIMSourceUserFromJSON,
    SCIMSourceUserToJSON,
    SCIMSourceUserRequestFromJSON,
    SCIMSourceUserRequestToJSON,
    SourceFromJSON,
    SourceToJSON,
    SourceTypeFromJSON,
    SourceTypeToJSON,
    SyncStatusFromJSON,
    SyncStatusToJSON,
    TypeCreateFromJSON,
    TypeCreateToJSON,
    UsedByFromJSON,
    UsedByToJSON,
    UserKerberosSourceConnectionFromJSON,
    UserKerberosSourceConnectionToJSON,
    UserKerberosSourceConnectionRequestFromJSON,
    UserKerberosSourceConnectionRequestToJSON,
    UserLDAPSourceConnectionFromJSON,
    UserLDAPSourceConnectionToJSON,
    UserLDAPSourceConnectionRequestFromJSON,
    UserLDAPSourceConnectionRequestToJSON,
    UserOAuthSourceConnectionFromJSON,
    UserOAuthSourceConnectionToJSON,
    UserOAuthSourceConnectionRequestFromJSON,
    UserOAuthSourceConnectionRequestToJSON,
    UserPlexSourceConnectionFromJSON,
    UserPlexSourceConnectionToJSON,
    UserPlexSourceConnectionRequestFromJSON,
    UserPlexSourceConnectionRequestToJSON,
    UserSAMLSourceConnectionFromJSON,
    UserSAMLSourceConnectionToJSON,
    UserSAMLSourceConnectionRequestFromJSON,
    UserSAMLSourceConnectionRequestToJSON,
    UserSettingFromJSON,
    UserSettingToJSON,
    UserSourceConnectionFromJSON,
    UserSourceConnectionToJSON,
    UserSourceConnectionRequestFromJSON,
    UserSourceConnectionRequestToJSON,
    ValidationErrorFromJSON,
    ValidationErrorToJSON,
} from '../models/index';

export interface SourcesAllDestroyRequest {
    slug: string;
}

export interface SourcesAllListRequest {
    managed?: string;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    pbmUuid?: string;
    search?: string;
    slug?: string;
}

export interface SourcesAllRetrieveRequest {
    slug: string;
}

export interface SourcesAllSetIconCreateRequest {
    slug: string;
    file?: Blob;
    clear?: boolean;
}

export interface SourcesAllSetIconUrlCreateRequest {
    slug: string;
    filePathRequest: FilePathRequest;
}

export interface SourcesAllUsedByListRequest {
    slug: string;
}

export interface SourcesGroupConnectionsAllDestroyRequest {
    id: number;
}

export interface SourcesGroupConnectionsAllListRequest {
    group?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
}

export interface SourcesGroupConnectionsAllPartialUpdateRequest {
    id: number;
    patchedGroupSourceConnectionRequest?: PatchedGroupSourceConnectionRequest;
}

export interface SourcesGroupConnectionsAllRetrieveRequest {
    id: number;
}

export interface SourcesGroupConnectionsAllUpdateRequest {
    id: number;
    groupSourceConnectionRequest: GroupSourceConnectionRequest;
}

export interface SourcesGroupConnectionsAllUsedByListRequest {
    id: number;
}

export interface SourcesGroupConnectionsKerberosCreateRequest {
    groupKerberosSourceConnectionRequest: GroupKerberosSourceConnectionRequest;
}

export interface SourcesGroupConnectionsKerberosDestroyRequest {
    id: number;
}

export interface SourcesGroupConnectionsKerberosListRequest {
    group?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
}

export interface SourcesGroupConnectionsKerberosPartialUpdateRequest {
    id: number;
    patchedGroupKerberosSourceConnectionRequest?: PatchedGroupKerberosSourceConnectionRequest;
}

export interface SourcesGroupConnectionsKerberosRetrieveRequest {
    id: number;
}

export interface SourcesGroupConnectionsKerberosUpdateRequest {
    id: number;
    groupKerberosSourceConnectionRequest: GroupKerberosSourceConnectionRequest;
}

export interface SourcesGroupConnectionsKerberosUsedByListRequest {
    id: number;
}

export interface SourcesGroupConnectionsLdapCreateRequest {
    groupLDAPSourceConnectionRequest: GroupLDAPSourceConnectionRequest;
}

export interface SourcesGroupConnectionsLdapDestroyRequest {
    id: number;
}

export interface SourcesGroupConnectionsLdapListRequest {
    group?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
}

export interface SourcesGroupConnectionsLdapPartialUpdateRequest {
    id: number;
    patchedGroupLDAPSourceConnectionRequest?: PatchedGroupLDAPSourceConnectionRequest;
}

export interface SourcesGroupConnectionsLdapRetrieveRequest {
    id: number;
}

export interface SourcesGroupConnectionsLdapUpdateRequest {
    id: number;
    groupLDAPSourceConnectionRequest: GroupLDAPSourceConnectionRequest;
}

export interface SourcesGroupConnectionsLdapUsedByListRequest {
    id: number;
}

export interface SourcesGroupConnectionsOauthCreateRequest {
    groupOAuthSourceConnectionRequest: GroupOAuthSourceConnectionRequest;
}

export interface SourcesGroupConnectionsOauthDestroyRequest {
    id: number;
}

export interface SourcesGroupConnectionsOauthListRequest {
    group?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
}

export interface SourcesGroupConnectionsOauthPartialUpdateRequest {
    id: number;
    patchedGroupOAuthSourceConnectionRequest?: PatchedGroupOAuthSourceConnectionRequest;
}

export interface SourcesGroupConnectionsOauthRetrieveRequest {
    id: number;
}

export interface SourcesGroupConnectionsOauthUpdateRequest {
    id: number;
    groupOAuthSourceConnectionRequest: GroupOAuthSourceConnectionRequest;
}

export interface SourcesGroupConnectionsOauthUsedByListRequest {
    id: number;
}

export interface SourcesGroupConnectionsPlexCreateRequest {
    groupPlexSourceConnectionRequest: GroupPlexSourceConnectionRequest;
}

export interface SourcesGroupConnectionsPlexDestroyRequest {
    id: number;
}

export interface SourcesGroupConnectionsPlexListRequest {
    group?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
}

export interface SourcesGroupConnectionsPlexPartialUpdateRequest {
    id: number;
    patchedGroupPlexSourceConnectionRequest?: PatchedGroupPlexSourceConnectionRequest;
}

export interface SourcesGroupConnectionsPlexRetrieveRequest {
    id: number;
}

export interface SourcesGroupConnectionsPlexUpdateRequest {
    id: number;
    groupPlexSourceConnectionRequest: GroupPlexSourceConnectionRequest;
}

export interface SourcesGroupConnectionsPlexUsedByListRequest {
    id: number;
}

export interface SourcesGroupConnectionsSamlCreateRequest {
    groupSAMLSourceConnectionRequest: GroupSAMLSourceConnectionRequest;
}

export interface SourcesGroupConnectionsSamlDestroyRequest {
    id: number;
}

export interface SourcesGroupConnectionsSamlListRequest {
    group?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
}

export interface SourcesGroupConnectionsSamlPartialUpdateRequest {
    id: number;
    patchedGroupSAMLSourceConnectionRequest?: PatchedGroupSAMLSourceConnectionRequest;
}

export interface SourcesGroupConnectionsSamlRetrieveRequest {
    id: number;
}

export interface SourcesGroupConnectionsSamlUpdateRequest {
    id: number;
    groupSAMLSourceConnectionRequest: GroupSAMLSourceConnectionRequest;
}

export interface SourcesGroupConnectionsSamlUsedByListRequest {
    id: number;
}

export interface SourcesKerberosCreateRequest {
    kerberosSourceRequest: KerberosSourceRequest;
}

export interface SourcesKerberosDestroyRequest {
    slug: string;
}

export interface SourcesKerberosListRequest {
    enabled?: boolean;
    kadminType?: SourcesKerberosListKadminTypeEnum;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    passwordLoginUpdateInternalPassword?: boolean;
    pbmUuid?: string;
    realm?: string;
    search?: string;
    slug?: string;
    spnegoServerName?: string;
    syncPrincipal?: string;
    syncUsers?: boolean;
    syncUsersPassword?: boolean;
}

export interface SourcesKerberosPartialUpdateRequest {
    slug: string;
    patchedKerberosSourceRequest?: PatchedKerberosSourceRequest;
}

export interface SourcesKerberosRetrieveRequest {
    slug: string;
}

export interface SourcesKerberosSyncStatusRetrieveRequest {
    slug: string;
}

export interface SourcesKerberosUpdateRequest {
    slug: string;
    kerberosSourceRequest: KerberosSourceRequest;
}

export interface SourcesKerberosUsedByListRequest {
    slug: string;
}

export interface SourcesLdapCreateRequest {
    lDAPSourceRequest: LDAPSourceRequest;
}

export interface SourcesLdapDebugRetrieveRequest {
    slug: string;
}

export interface SourcesLdapDestroyRequest {
    slug: string;
}

export interface SourcesLdapListRequest {
    additionalGroupDn?: string;
    additionalUserDn?: string;
    baseDn?: string;
    bindCn?: string;
    clientCertificate?: string;
    deleteNotFoundObjects?: boolean;
    enabled?: boolean;
    groupMembershipField?: string;
    groupObjectFilter?: string;
    groupPropertyMappings?: Array<string>;
    lookupGroupsFromUser?: boolean;
    name?: string;
    objectUniquenessField?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    passwordLoginUpdateInternalPassword?: boolean;
    pbmUuid?: string;
    peerCertificate?: string;
    search?: string;
    serverUri?: string;
    slug?: string;
    sni?: boolean;
    startTls?: boolean;
    syncGroups?: boolean;
    syncParentGroup?: string;
    syncUsers?: boolean;
    syncUsersPassword?: boolean;
    userMembershipAttribute?: string;
    userObjectFilter?: string;
    userPropertyMappings?: Array<string>;
}

export interface SourcesLdapPartialUpdateRequest {
    slug: string;
    patchedLDAPSourceRequest?: PatchedLDAPSourceRequest;
}

export interface SourcesLdapRetrieveRequest {
    slug: string;
}

export interface SourcesLdapSyncStatusRetrieveRequest {
    slug: string;
}

export interface SourcesLdapUpdateRequest {
    slug: string;
    lDAPSourceRequest: LDAPSourceRequest;
}

export interface SourcesLdapUsedByListRequest {
    slug: string;
}

export interface SourcesOauthCreateRequest {
    oAuthSourceRequest: OAuthSourceRequest;
}

export interface SourcesOauthDestroyRequest {
    slug: string;
}

export interface SourcesOauthListRequest {
    accessTokenUrl?: string;
    additionalScopes?: string;
    authenticationFlow?: string;
    authorizationUrl?: string;
    consumerKey?: string;
    enabled?: boolean;
    enrollmentFlow?: string;
    groupMatchingMode?: SourcesOauthListGroupMatchingModeEnum;
    hasJwks?: boolean;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    pbmUuid?: string;
    policyEngineMode?: SourcesOauthListPolicyEngineModeEnum;
    profileUrl?: string;
    providerType?: string;
    requestTokenUrl?: string;
    search?: string;
    slug?: string;
    userMatchingMode?: SourcesOauthListUserMatchingModeEnum;
}

export interface SourcesOauthPartialUpdateRequest {
    slug: string;
    patchedOAuthSourceRequest?: PatchedOAuthSourceRequest;
}

export interface SourcesOauthRetrieveRequest {
    slug: string;
}

export interface SourcesOauthSourceTypesListRequest {
    name?: string;
}

export interface SourcesOauthUpdateRequest {
    slug: string;
    oAuthSourceRequest: OAuthSourceRequest;
}

export interface SourcesOauthUsedByListRequest {
    slug: string;
}

export interface SourcesPlexCreateRequest {
    plexSourceRequest: PlexSourceRequest;
}

export interface SourcesPlexDestroyRequest {
    slug: string;
}

export interface SourcesPlexListRequest {
    allowFriends?: boolean;
    authenticationFlow?: string;
    clientId?: string;
    enabled?: boolean;
    enrollmentFlow?: string;
    groupMatchingMode?: SourcesPlexListGroupMatchingModeEnum;
    name?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    pbmUuid?: string;
    policyEngineMode?: SourcesPlexListPolicyEngineModeEnum;
    search?: string;
    slug?: string;
    userMatchingMode?: SourcesPlexListUserMatchingModeEnum;
}

export interface SourcesPlexPartialUpdateRequest {
    slug: string;
    patchedPlexSourceRequest?: PatchedPlexSourceRequest;
}

export interface SourcesPlexRedeemTokenAuthenticatedCreateRequest {
    plexTokenRedeemRequest: PlexTokenRedeemRequest;
    slug?: string;
}

export interface SourcesPlexRedeemTokenCreateRequest {
    plexTokenRedeemRequest: PlexTokenRedeemRequest;
    slug?: string;
}

export interface SourcesPlexRetrieveRequest {
    slug: string;
}

export interface SourcesPlexUpdateRequest {
    slug: string;
    plexSourceRequest: PlexSourceRequest;
}

export interface SourcesPlexUsedByListRequest {
    slug: string;
}

export interface SourcesSamlCreateRequest {
    sAMLSourceRequest: SAMLSourceRequest;
}

export interface SourcesSamlDestroyRequest {
    slug: string;
}

export interface SourcesSamlListRequest {
    allowIdpInitiated?: boolean;
    authenticationFlow?: string;
    bindingType?: SourcesSamlListBindingTypeEnum;
    digestAlgorithm?: SourcesSamlListDigestAlgorithmEnum;
    enabled?: boolean;
    enrollmentFlow?: string;
    issuer?: string;
    managed?: string;
    name?: string;
    nameIdPolicy?: SourcesSamlListNameIdPolicyEnum;
    ordering?: string;
    page?: number;
    pageSize?: number;
    pbmUuid?: string;
    policyEngineMode?: SourcesSamlListPolicyEngineModeEnum;
    preAuthenticationFlow?: string;
    search?: string;
    signatureAlgorithm?: SourcesSamlListSignatureAlgorithmEnum;
    signingKp?: string;
    sloUrl?: string;
    slug?: string;
    ssoUrl?: string;
    temporaryUserDeleteAfter?: string;
    userMatchingMode?: SourcesSamlListUserMatchingModeEnum;
    verificationKp?: string;
}

export interface SourcesSamlMetadataRetrieveRequest {
    slug: string;
}

export interface SourcesSamlPartialUpdateRequest {
    slug: string;
    patchedSAMLSourceRequest?: PatchedSAMLSourceRequest;
}

export interface SourcesSamlRetrieveRequest {
    slug: string;
}

export interface SourcesSamlUpdateRequest {
    slug: string;
    sAMLSourceRequest: SAMLSourceRequest;
}

export interface SourcesSamlUsedByListRequest {
    slug: string;
}

export interface SourcesScimCreateRequest {
    sCIMSourceRequest: SCIMSourceRequest;
}

export interface SourcesScimDestroyRequest {
    slug: string;
}

export interface SourcesScimGroupsCreateRequest {
    sCIMSourceGroupRequest: SCIMSourceGroupRequest;
}

export interface SourcesScimGroupsDestroyRequest {
    id: string;
}

export interface SourcesScimGroupsListRequest {
    groupGroupUuid?: string;
    groupName?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
}

export interface SourcesScimGroupsPartialUpdateRequest {
    id: string;
    patchedSCIMSourceGroupRequest?: PatchedSCIMSourceGroupRequest;
}

export interface SourcesScimGroupsRetrieveRequest {
    id: string;
}

export interface SourcesScimGroupsUpdateRequest {
    id: string;
    sCIMSourceGroupRequest: SCIMSourceGroupRequest;
}

export interface SourcesScimGroupsUsedByListRequest {
    id: string;
}

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

export interface SourcesScimPartialUpdateRequest {
    slug: string;
    patchedSCIMSourceRequest?: PatchedSCIMSourceRequest;
}

export interface SourcesScimRetrieveRequest {
    slug: string;
}

export interface SourcesScimUpdateRequest {
    slug: string;
    sCIMSourceRequest: SCIMSourceRequest;
}

export interface SourcesScimUsedByListRequest {
    slug: string;
}

export interface SourcesScimUsersCreateRequest {
    sCIMSourceUserRequest: SCIMSourceUserRequest;
}

export interface SourcesScimUsersDestroyRequest {
    id: string;
}

export interface SourcesScimUsersListRequest {
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
    userId?: number;
    userUsername?: string;
}

export interface SourcesScimUsersPartialUpdateRequest {
    id: string;
    patchedSCIMSourceUserRequest?: PatchedSCIMSourceUserRequest;
}

export interface SourcesScimUsersRetrieveRequest {
    id: string;
}

export interface SourcesScimUsersUpdateRequest {
    id: string;
    sCIMSourceUserRequest: SCIMSourceUserRequest;
}

export interface SourcesScimUsersUsedByListRequest {
    id: string;
}

export interface SourcesUserConnectionsAllDestroyRequest {
    id: number;
}

export interface SourcesUserConnectionsAllListRequest {
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
    user?: number;
}

export interface SourcesUserConnectionsAllPartialUpdateRequest {
    id: number;
    patchedUserSourceConnectionRequest?: PatchedUserSourceConnectionRequest;
}

export interface SourcesUserConnectionsAllRetrieveRequest {
    id: number;
}

export interface SourcesUserConnectionsAllUpdateRequest {
    id: number;
    userSourceConnectionRequest: UserSourceConnectionRequest;
}

export interface SourcesUserConnectionsAllUsedByListRequest {
    id: number;
}

export interface SourcesUserConnectionsKerberosCreateRequest {
    userKerberosSourceConnectionRequest: UserKerberosSourceConnectionRequest;
}

export interface SourcesUserConnectionsKerberosDestroyRequest {
    id: number;
}

export interface SourcesUserConnectionsKerberosListRequest {
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
    user?: number;
}

export interface SourcesUserConnectionsKerberosPartialUpdateRequest {
    id: number;
    patchedUserKerberosSourceConnectionRequest?: PatchedUserKerberosSourceConnectionRequest;
}

export interface SourcesUserConnectionsKerberosRetrieveRequest {
    id: number;
}

export interface SourcesUserConnectionsKerberosUpdateRequest {
    id: number;
    userKerberosSourceConnectionRequest: UserKerberosSourceConnectionRequest;
}

export interface SourcesUserConnectionsKerberosUsedByListRequest {
    id: number;
}

export interface SourcesUserConnectionsLdapCreateRequest {
    userLDAPSourceConnectionRequest: UserLDAPSourceConnectionRequest;
}

export interface SourcesUserConnectionsLdapDestroyRequest {
    id: number;
}

export interface SourcesUserConnectionsLdapListRequest {
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
    user?: number;
}

export interface SourcesUserConnectionsLdapPartialUpdateRequest {
    id: number;
    patchedUserLDAPSourceConnectionRequest?: PatchedUserLDAPSourceConnectionRequest;
}

export interface SourcesUserConnectionsLdapRetrieveRequest {
    id: number;
}

export interface SourcesUserConnectionsLdapUpdateRequest {
    id: number;
    userLDAPSourceConnectionRequest: UserLDAPSourceConnectionRequest;
}

export interface SourcesUserConnectionsLdapUsedByListRequest {
    id: number;
}

export interface SourcesUserConnectionsOauthCreateRequest {
    userOAuthSourceConnectionRequest: UserOAuthSourceConnectionRequest;
}

export interface SourcesUserConnectionsOauthDestroyRequest {
    id: number;
}

export interface SourcesUserConnectionsOauthListRequest {
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
    user?: number;
}

export interface SourcesUserConnectionsOauthPartialUpdateRequest {
    id: number;
    patchedUserOAuthSourceConnectionRequest?: PatchedUserOAuthSourceConnectionRequest;
}

export interface SourcesUserConnectionsOauthRetrieveRequest {
    id: number;
}

export interface SourcesUserConnectionsOauthUpdateRequest {
    id: number;
    userOAuthSourceConnectionRequest: UserOAuthSourceConnectionRequest;
}

export interface SourcesUserConnectionsOauthUsedByListRequest {
    id: number;
}

export interface SourcesUserConnectionsPlexCreateRequest {
    userPlexSourceConnectionRequest: UserPlexSourceConnectionRequest;
}

export interface SourcesUserConnectionsPlexDestroyRequest {
    id: number;
}

export interface SourcesUserConnectionsPlexListRequest {
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
    user?: number;
}

export interface SourcesUserConnectionsPlexPartialUpdateRequest {
    id: number;
    patchedUserPlexSourceConnectionRequest?: PatchedUserPlexSourceConnectionRequest;
}

export interface SourcesUserConnectionsPlexRetrieveRequest {
    id: number;
}

export interface SourcesUserConnectionsPlexUpdateRequest {
    id: number;
    userPlexSourceConnectionRequest: UserPlexSourceConnectionRequest;
}

export interface SourcesUserConnectionsPlexUsedByListRequest {
    id: number;
}

export interface SourcesUserConnectionsSamlCreateRequest {
    userSAMLSourceConnectionRequest: UserSAMLSourceConnectionRequest;
}

export interface SourcesUserConnectionsSamlDestroyRequest {
    id: number;
}

export interface SourcesUserConnectionsSamlListRequest {
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    sourceSlug?: string;
    user?: number;
}

export interface SourcesUserConnectionsSamlPartialUpdateRequest {
    id: number;
    patchedUserSAMLSourceConnectionRequest?: PatchedUserSAMLSourceConnectionRequest;
}

export interface SourcesUserConnectionsSamlRetrieveRequest {
    id: number;
}

export interface SourcesUserConnectionsSamlUpdateRequest {
    id: number;
    userSAMLSourceConnectionRequest: UserSAMLSourceConnectionRequest;
}

export interface SourcesUserConnectionsSamlUsedByListRequest {
    id: number;
}

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

    /**
     * Prevent deletion of built-in sources
     */
    async sourcesAllDestroyRaw(requestParameters: SourcesAllDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesAllDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/all/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Prevent deletion of built-in sources
     */
    async sourcesAllDestroy(requestParameters: SourcesAllDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesAllDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Source Viewset
     */
    async sourcesAllListRaw(requestParameters: SourcesAllListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedSourceList>> {
        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['pbmUuid'] != null) {
            queryParameters['pbm_uuid'] = requestParameters['pbmUuid'];
        }

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/all/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Source Viewset
     */
    async sourcesAllList(requestParameters: SourcesAllListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedSourceList> {
        const response = await this.sourcesAllListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Source Viewset
     */
    async sourcesAllRetrieveRaw(requestParameters: SourcesAllRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Source>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesAllRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/all/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Source Viewset
     */
    async sourcesAllRetrieve(requestParameters: SourcesAllRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Source> {
        const response = await this.sourcesAllRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Set source icon
     */
    async sourcesAllSetIconCreateRaw(requestParameters: SourcesAllSetIconCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesAllSetIconCreate().'
            );
        }

        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}`;
            }
        }
        const consumes: runtime.Consume[] = [
            { contentType: 'multipart/form-data' },
        ];
        // @ts-ignore: canConsumeForm may be unused
        const canConsumeForm = runtime.canConsumeForm(consumes);

        let formParams: { append(param: string, value: any): any };
        let useForm = false;
        // use FormData to transmit files using content-type "multipart/form-data"
        useForm = canConsumeForm;
        if (useForm) {
            formParams = new FormData();
        } else {
            formParams = new URLSearchParams();
        }

        if (requestParameters['file'] != null) {
            formParams.append('file', requestParameters['file'] as any);
        }

        if (requestParameters['clear'] != null) {
            formParams.append('clear', requestParameters['clear'] as any);
        }

        const response = await this.request({
            path: `/sources/all/{slug}/set_icon/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: formParams,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Set source icon
     */
    async sourcesAllSetIconCreate(requestParameters: SourcesAllSetIconCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesAllSetIconCreateRaw(requestParameters, initOverrides);
    }

    /**
     * Set source icon (as URL)
     */
    async sourcesAllSetIconUrlCreateRaw(requestParameters: SourcesAllSetIconUrlCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesAllSetIconUrlCreate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/all/{slug}/set_icon_url/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FilePathRequestToJSON(requestParameters['filePathRequest']),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Set source icon (as URL)
     */
    async sourcesAllSetIconUrlCreate(requestParameters: SourcesAllSetIconUrlCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesAllSetIconUrlCreateRaw(requestParameters, initOverrides);
    }

    /**
     * Get all creatable types
     */
    async sourcesAllTypesListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<TypeCreate>>> {
        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/all/types/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * Get a list of all objects that use this object
     */
    async sourcesAllUsedByListRaw(requestParameters: SourcesAllUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesAllUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/all/{slug}/used_by/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * Get all sources the user can configure
     */
    async sourcesAllUserSettingsListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UserSetting>>> {
        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/all/user_settings/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Get all sources the user can configure
     */
    async sourcesAllUserSettingsList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UserSetting>> {
        const response = await this.sourcesAllUserSettingsListRaw(initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsAllDestroyRaw(requestParameters: SourcesGroupConnectionsAllDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsAllDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/all/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsAllDestroy(requestParameters: SourcesGroupConnectionsAllDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesGroupConnectionsAllDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsAllListRaw(requestParameters: SourcesGroupConnectionsAllListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGroupSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/all/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsAllList(requestParameters: SourcesGroupConnectionsAllListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedGroupSourceConnectionList> {
        const response = await this.sourcesGroupConnectionsAllListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsAllPartialUpdateRaw(requestParameters: SourcesGroupConnectionsAllPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsAllPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/all/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedGroupSourceConnectionRequestToJSON(requestParameters['patchedGroupSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsAllPartialUpdate(requestParameters: SourcesGroupConnectionsAllPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupSourceConnection> {
        const response = await this.sourcesGroupConnectionsAllPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsAllRetrieveRaw(requestParameters: SourcesGroupConnectionsAllRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsAllRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/all/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsAllRetrieve(requestParameters: SourcesGroupConnectionsAllRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupSourceConnection> {
        const response = await this.sourcesGroupConnectionsAllRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsAllUpdateRaw(requestParameters: SourcesGroupConnectionsAllUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsAllUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/all/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: GroupSourceConnectionRequestToJSON(requestParameters['groupSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsAllUpdate(requestParameters: SourcesGroupConnectionsAllUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupSourceConnection> {
        const response = await this.sourcesGroupConnectionsAllUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesGroupConnectionsAllUsedByListRaw(requestParameters: SourcesGroupConnectionsAllUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsAllUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/all/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosCreateRaw(requestParameters: SourcesGroupConnectionsKerberosCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupKerberosSourceConnection>> {
        if (requestParameters['groupKerberosSourceConnectionRequest'] == null) {
            throw new runtime.RequiredError(
                'groupKerberosSourceConnectionRequest',
                'Required parameter "groupKerberosSourceConnectionRequest" was null or undefined when calling sourcesGroupConnectionsKerberosCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/kerberos/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: GroupKerberosSourceConnectionRequestToJSON(requestParameters['groupKerberosSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosCreate(requestParameters: SourcesGroupConnectionsKerberosCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupKerberosSourceConnection> {
        const response = await this.sourcesGroupConnectionsKerberosCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosDestroyRaw(requestParameters: SourcesGroupConnectionsKerberosDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsKerberosDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/kerberos/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosDestroy(requestParameters: SourcesGroupConnectionsKerberosDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesGroupConnectionsKerberosDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosListRaw(requestParameters: SourcesGroupConnectionsKerberosListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGroupKerberosSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/kerberos/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosList(requestParameters: SourcesGroupConnectionsKerberosListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedGroupKerberosSourceConnectionList> {
        const response = await this.sourcesGroupConnectionsKerberosListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosPartialUpdateRaw(requestParameters: SourcesGroupConnectionsKerberosPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupKerberosSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsKerberosPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/kerberos/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedGroupKerberosSourceConnectionRequestToJSON(requestParameters['patchedGroupKerberosSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosPartialUpdate(requestParameters: SourcesGroupConnectionsKerberosPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupKerberosSourceConnection> {
        const response = await this.sourcesGroupConnectionsKerberosPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosRetrieveRaw(requestParameters: SourcesGroupConnectionsKerberosRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupKerberosSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsKerberosRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/kerberos/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosRetrieve(requestParameters: SourcesGroupConnectionsKerberosRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupKerberosSourceConnection> {
        const response = await this.sourcesGroupConnectionsKerberosRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosUpdateRaw(requestParameters: SourcesGroupConnectionsKerberosUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupKerberosSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsKerberosUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/kerberos/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: GroupKerberosSourceConnectionRequestToJSON(requestParameters['groupKerberosSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsKerberosUpdate(requestParameters: SourcesGroupConnectionsKerberosUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupKerberosSourceConnection> {
        const response = await this.sourcesGroupConnectionsKerberosUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesGroupConnectionsKerberosUsedByListRaw(requestParameters: SourcesGroupConnectionsKerberosUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsKerberosUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/kerberos/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapCreateRaw(requestParameters: SourcesGroupConnectionsLdapCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupLDAPSourceConnection>> {
        if (requestParameters['groupLDAPSourceConnectionRequest'] == null) {
            throw new runtime.RequiredError(
                'groupLDAPSourceConnectionRequest',
                'Required parameter "groupLDAPSourceConnectionRequest" was null or undefined when calling sourcesGroupConnectionsLdapCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/ldap/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: GroupLDAPSourceConnectionRequestToJSON(requestParameters['groupLDAPSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapCreate(requestParameters: SourcesGroupConnectionsLdapCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupLDAPSourceConnection> {
        const response = await this.sourcesGroupConnectionsLdapCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapDestroyRaw(requestParameters: SourcesGroupConnectionsLdapDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsLdapDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/ldap/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapDestroy(requestParameters: SourcesGroupConnectionsLdapDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesGroupConnectionsLdapDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapListRaw(requestParameters: SourcesGroupConnectionsLdapListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGroupLDAPSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/ldap/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapList(requestParameters: SourcesGroupConnectionsLdapListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedGroupLDAPSourceConnectionList> {
        const response = await this.sourcesGroupConnectionsLdapListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapPartialUpdateRaw(requestParameters: SourcesGroupConnectionsLdapPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupLDAPSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsLdapPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/ldap/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedGroupLDAPSourceConnectionRequestToJSON(requestParameters['patchedGroupLDAPSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapPartialUpdate(requestParameters: SourcesGroupConnectionsLdapPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupLDAPSourceConnection> {
        const response = await this.sourcesGroupConnectionsLdapPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapRetrieveRaw(requestParameters: SourcesGroupConnectionsLdapRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupLDAPSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsLdapRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/ldap/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapRetrieve(requestParameters: SourcesGroupConnectionsLdapRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupLDAPSourceConnection> {
        const response = await this.sourcesGroupConnectionsLdapRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapUpdateRaw(requestParameters: SourcesGroupConnectionsLdapUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupLDAPSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsLdapUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/ldap/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: GroupLDAPSourceConnectionRequestToJSON(requestParameters['groupLDAPSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsLdapUpdate(requestParameters: SourcesGroupConnectionsLdapUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupLDAPSourceConnection> {
        const response = await this.sourcesGroupConnectionsLdapUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesGroupConnectionsLdapUsedByListRaw(requestParameters: SourcesGroupConnectionsLdapUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsLdapUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/ldap/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthCreateRaw(requestParameters: SourcesGroupConnectionsOauthCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
        if (requestParameters['groupOAuthSourceConnectionRequest'] == null) {
            throw new runtime.RequiredError(
                'groupOAuthSourceConnectionRequest',
                'Required parameter "groupOAuthSourceConnectionRequest" was null or undefined when calling sourcesGroupConnectionsOauthCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/oauth/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: GroupOAuthSourceConnectionRequestToJSON(requestParameters['groupOAuthSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthCreate(requestParameters: SourcesGroupConnectionsOauthCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupOAuthSourceConnection> {
        const response = await this.sourcesGroupConnectionsOauthCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthDestroyRaw(requestParameters: SourcesGroupConnectionsOauthDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsOauthDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthDestroy(requestParameters: SourcesGroupConnectionsOauthDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesGroupConnectionsOauthDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthListRaw(requestParameters: SourcesGroupConnectionsOauthListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGroupOAuthSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/oauth/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthList(requestParameters: SourcesGroupConnectionsOauthListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedGroupOAuthSourceConnectionList> {
        const response = await this.sourcesGroupConnectionsOauthListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthPartialUpdateRaw(requestParameters: SourcesGroupConnectionsOauthPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsOauthPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedGroupOAuthSourceConnectionRequestToJSON(requestParameters['patchedGroupOAuthSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthPartialUpdate(requestParameters: SourcesGroupConnectionsOauthPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupOAuthSourceConnection> {
        const response = await this.sourcesGroupConnectionsOauthPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthRetrieveRaw(requestParameters: SourcesGroupConnectionsOauthRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsOauthRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthRetrieve(requestParameters: SourcesGroupConnectionsOauthRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupOAuthSourceConnection> {
        const response = await this.sourcesGroupConnectionsOauthRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthUpdateRaw(requestParameters: SourcesGroupConnectionsOauthUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsOauthUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: GroupOAuthSourceConnectionRequestToJSON(requestParameters['groupOAuthSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsOauthUpdate(requestParameters: SourcesGroupConnectionsOauthUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupOAuthSourceConnection> {
        const response = await this.sourcesGroupConnectionsOauthUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesGroupConnectionsOauthUsedByListRaw(requestParameters: SourcesGroupConnectionsOauthUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsOauthUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/oauth/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexCreateRaw(requestParameters: SourcesGroupConnectionsPlexCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupPlexSourceConnection>> {
        if (requestParameters['groupPlexSourceConnectionRequest'] == null) {
            throw new runtime.RequiredError(
                'groupPlexSourceConnectionRequest',
                'Required parameter "groupPlexSourceConnectionRequest" was null or undefined when calling sourcesGroupConnectionsPlexCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/plex/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: GroupPlexSourceConnectionRequestToJSON(requestParameters['groupPlexSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexCreate(requestParameters: SourcesGroupConnectionsPlexCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupPlexSourceConnection> {
        const response = await this.sourcesGroupConnectionsPlexCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexDestroyRaw(requestParameters: SourcesGroupConnectionsPlexDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsPlexDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexDestroy(requestParameters: SourcesGroupConnectionsPlexDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesGroupConnectionsPlexDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexListRaw(requestParameters: SourcesGroupConnectionsPlexListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGroupPlexSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/plex/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexList(requestParameters: SourcesGroupConnectionsPlexListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedGroupPlexSourceConnectionList> {
        const response = await this.sourcesGroupConnectionsPlexListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexPartialUpdateRaw(requestParameters: SourcesGroupConnectionsPlexPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupPlexSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsPlexPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedGroupPlexSourceConnectionRequestToJSON(requestParameters['patchedGroupPlexSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexPartialUpdate(requestParameters: SourcesGroupConnectionsPlexPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupPlexSourceConnection> {
        const response = await this.sourcesGroupConnectionsPlexPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexRetrieveRaw(requestParameters: SourcesGroupConnectionsPlexRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupPlexSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsPlexRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexRetrieve(requestParameters: SourcesGroupConnectionsPlexRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupPlexSourceConnection> {
        const response = await this.sourcesGroupConnectionsPlexRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexUpdateRaw(requestParameters: SourcesGroupConnectionsPlexUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupPlexSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsPlexUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: GroupPlexSourceConnectionRequestToJSON(requestParameters['groupPlexSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsPlexUpdate(requestParameters: SourcesGroupConnectionsPlexUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupPlexSourceConnection> {
        const response = await this.sourcesGroupConnectionsPlexUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesGroupConnectionsPlexUsedByListRaw(requestParameters: SourcesGroupConnectionsPlexUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsPlexUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/plex/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlCreateRaw(requestParameters: SourcesGroupConnectionsSamlCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupSAMLSourceConnection>> {
        if (requestParameters['groupSAMLSourceConnectionRequest'] == null) {
            throw new runtime.RequiredError(
                'groupSAMLSourceConnectionRequest',
                'Required parameter "groupSAMLSourceConnectionRequest" was null or undefined when calling sourcesGroupConnectionsSamlCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/saml/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: GroupSAMLSourceConnectionRequestToJSON(requestParameters['groupSAMLSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlCreate(requestParameters: SourcesGroupConnectionsSamlCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupSAMLSourceConnection> {
        const response = await this.sourcesGroupConnectionsSamlCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlDestroyRaw(requestParameters: SourcesGroupConnectionsSamlDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsSamlDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/saml/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlDestroy(requestParameters: SourcesGroupConnectionsSamlDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesGroupConnectionsSamlDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlListRaw(requestParameters: SourcesGroupConnectionsSamlListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGroupSAMLSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/saml/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlList(requestParameters: SourcesGroupConnectionsSamlListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedGroupSAMLSourceConnectionList> {
        const response = await this.sourcesGroupConnectionsSamlListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlPartialUpdateRaw(requestParameters: SourcesGroupConnectionsSamlPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupSAMLSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsSamlPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/saml/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedGroupSAMLSourceConnectionRequestToJSON(requestParameters['patchedGroupSAMLSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlPartialUpdate(requestParameters: SourcesGroupConnectionsSamlPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupSAMLSourceConnection> {
        const response = await this.sourcesGroupConnectionsSamlPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlRetrieveRaw(requestParameters: SourcesGroupConnectionsSamlRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupSAMLSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsSamlRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/saml/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlRetrieve(requestParameters: SourcesGroupConnectionsSamlRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupSAMLSourceConnection> {
        const response = await this.sourcesGroupConnectionsSamlRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlUpdateRaw(requestParameters: SourcesGroupConnectionsSamlUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupSAMLSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsSamlUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/saml/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: GroupSAMLSourceConnectionRequestToJSON(requestParameters['groupSAMLSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * Group-source connection Viewset
     */
    async sourcesGroupConnectionsSamlUpdate(requestParameters: SourcesGroupConnectionsSamlUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupSAMLSourceConnection> {
        const response = await this.sourcesGroupConnectionsSamlUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesGroupConnectionsSamlUsedByListRaw(requestParameters: SourcesGroupConnectionsSamlUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesGroupConnectionsSamlUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/group_connections/saml/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosCreateRaw(requestParameters: SourcesKerberosCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<KerberosSource>> {
        if (requestParameters['kerberosSourceRequest'] == null) {
            throw new runtime.RequiredError(
                'kerberosSourceRequest',
                'Required parameter "kerberosSourceRequest" was null or undefined when calling sourcesKerberosCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/kerberos/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: KerberosSourceRequestToJSON(requestParameters['kerberosSourceRequest']),
        }, initOverrides);

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

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosCreate(requestParameters: SourcesKerberosCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<KerberosSource> {
        const response = await this.sourcesKerberosCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosDestroyRaw(requestParameters: SourcesKerberosDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesKerberosDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/kerberos/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosDestroy(requestParameters: SourcesKerberosDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesKerberosDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosListRaw(requestParameters: SourcesKerberosListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedKerberosSourceList>> {
        const queryParameters: any = {};

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

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

        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['passwordLoginUpdateInternalPassword'] != null) {
            queryParameters['password_login_update_internal_password'] = requestParameters['passwordLoginUpdateInternalPassword'];
        }

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

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

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/kerberos/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosList(requestParameters: SourcesKerberosListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedKerberosSourceList> {
        const response = await this.sourcesKerberosListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosPartialUpdateRaw(requestParameters: SourcesKerberosPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<KerberosSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesKerberosPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/kerberos/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedKerberosSourceRequestToJSON(requestParameters['patchedKerberosSourceRequest']),
        }, initOverrides);

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

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosPartialUpdate(requestParameters: SourcesKerberosPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<KerberosSource> {
        const response = await this.sourcesKerberosPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosRetrieveRaw(requestParameters: SourcesKerberosRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<KerberosSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesKerberosRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/kerberos/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosRetrieve(requestParameters: SourcesKerberosRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<KerberosSource> {
        const response = await this.sourcesKerberosRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get source\'s sync status
     */
    async sourcesKerberosSyncStatusRetrieveRaw(requestParameters: SourcesKerberosSyncStatusRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<KerberosSyncStatus>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesKerberosSyncStatusRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/kerberos/{slug}/sync/status/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Get source\'s sync status
     */
    async sourcesKerberosSyncStatusRetrieve(requestParameters: SourcesKerberosSyncStatusRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<KerberosSyncStatus> {
        const response = await this.sourcesKerberosSyncStatusRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosUpdateRaw(requestParameters: SourcesKerberosUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<KerberosSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesKerberosUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/kerberos/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: KerberosSourceRequestToJSON(requestParameters['kerberosSourceRequest']),
        }, initOverrides);

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

    /**
     * Kerberos Source Viewset
     */
    async sourcesKerberosUpdate(requestParameters: SourcesKerberosUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<KerberosSource> {
        const response = await this.sourcesKerberosUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesKerberosUsedByListRaw(requestParameters: SourcesKerberosUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesKerberosUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/kerberos/{slug}/used_by/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapCreateRaw(requestParameters: SourcesLdapCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LDAPSource>> {
        if (requestParameters['lDAPSourceRequest'] == null) {
            throw new runtime.RequiredError(
                'lDAPSourceRequest',
                'Required parameter "lDAPSourceRequest" was null or undefined when calling sourcesLdapCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/ldap/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: LDAPSourceRequestToJSON(requestParameters['lDAPSourceRequest']),
        }, initOverrides);

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

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapCreate(requestParameters: SourcesLdapCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LDAPSource> {
        const response = await this.sourcesLdapCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get raw LDAP data to debug
     */
    async sourcesLdapDebugRetrieveRaw(requestParameters: SourcesLdapDebugRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LDAPDebug>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesLdapDebugRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/ldap/{slug}/debug/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Get raw LDAP data to debug
     */
    async sourcesLdapDebugRetrieve(requestParameters: SourcesLdapDebugRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LDAPDebug> {
        const response = await this.sourcesLdapDebugRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapDestroyRaw(requestParameters: SourcesLdapDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesLdapDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/ldap/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapDestroy(requestParameters: SourcesLdapDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesLdapDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapListRaw(requestParameters: SourcesLdapListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedLDAPSourceList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

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

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

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

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

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

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

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

        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['passwordLoginUpdateInternalPassword'] != null) {
            queryParameters['password_login_update_internal_password'] = requestParameters['passwordLoginUpdateInternalPassword'];
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/ldap/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapList(requestParameters: SourcesLdapListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedLDAPSourceList> {
        const response = await this.sourcesLdapListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapPartialUpdateRaw(requestParameters: SourcesLdapPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LDAPSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesLdapPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/ldap/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedLDAPSourceRequestToJSON(requestParameters['patchedLDAPSourceRequest']),
        }, initOverrides);

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

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapPartialUpdate(requestParameters: SourcesLdapPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LDAPSource> {
        const response = await this.sourcesLdapPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapRetrieveRaw(requestParameters: SourcesLdapRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LDAPSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesLdapRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/ldap/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapRetrieve(requestParameters: SourcesLdapRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LDAPSource> {
        const response = await this.sourcesLdapRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get source\'s sync status
     */
    async sourcesLdapSyncStatusRetrieveRaw(requestParameters: SourcesLdapSyncStatusRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SyncStatus>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesLdapSyncStatusRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/ldap/{slug}/sync/status/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Get source\'s sync status
     */
    async sourcesLdapSyncStatusRetrieve(requestParameters: SourcesLdapSyncStatusRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SyncStatus> {
        const response = await this.sourcesLdapSyncStatusRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapUpdateRaw(requestParameters: SourcesLdapUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LDAPSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesLdapUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/ldap/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: LDAPSourceRequestToJSON(requestParameters['lDAPSourceRequest']),
        }, initOverrides);

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

    /**
     * LDAP Source Viewset
     */
    async sourcesLdapUpdate(requestParameters: SourcesLdapUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LDAPSource> {
        const response = await this.sourcesLdapUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesLdapUsedByListRaw(requestParameters: SourcesLdapUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesLdapUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/ldap/{slug}/used_by/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * Source Viewset
     */
    async sourcesOauthCreateRaw(requestParameters: SourcesOauthCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OAuthSource>> {
        if (requestParameters['oAuthSourceRequest'] == null) {
            throw new runtime.RequiredError(
                'oAuthSourceRequest',
                'Required parameter "oAuthSourceRequest" was null or undefined when calling sourcesOauthCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/oauth/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: OAuthSourceRequestToJSON(requestParameters['oAuthSourceRequest']),
        }, initOverrides);

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

    /**
     * Source Viewset
     */
    async sourcesOauthCreate(requestParameters: SourcesOauthCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OAuthSource> {
        const response = await this.sourcesOauthCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Source Viewset
     */
    async sourcesOauthDestroyRaw(requestParameters: SourcesOauthDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesOauthDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/oauth/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Source Viewset
     */
    async sourcesOauthDestroy(requestParameters: SourcesOauthDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesOauthDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Source Viewset
     */
    async sourcesOauthListRaw(requestParameters: SourcesOauthListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedOAuthSourceList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/oauth/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Source Viewset
     */
    async sourcesOauthList(requestParameters: SourcesOauthListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedOAuthSourceList> {
        const response = await this.sourcesOauthListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Source Viewset
     */
    async sourcesOauthPartialUpdateRaw(requestParameters: SourcesOauthPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OAuthSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesOauthPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/oauth/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedOAuthSourceRequestToJSON(requestParameters['patchedOAuthSourceRequest']),
        }, initOverrides);

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

    /**
     * Source Viewset
     */
    async sourcesOauthPartialUpdate(requestParameters: SourcesOauthPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OAuthSource> {
        const response = await this.sourcesOauthPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Source Viewset
     */
    async sourcesOauthRetrieveRaw(requestParameters: SourcesOauthRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OAuthSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesOauthRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/oauth/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Source Viewset
     */
    async sourcesOauthRetrieve(requestParameters: SourcesOauthRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OAuthSource> {
        const response = await this.sourcesOauthRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get all creatable source types. If ?name is set, only returns the type for <name>. If <name> isn\'t found, returns the default type.
     */
    async sourcesOauthSourceTypesListRaw(requestParameters: SourcesOauthSourceTypesListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<SourceType>>> {
        const queryParameters: any = {};

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/oauth/source_types/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Get all creatable source types. If ?name is set, only returns the type for <name>. If <name> isn\'t found, returns the default type.
     */
    async sourcesOauthSourceTypesList(requestParameters: SourcesOauthSourceTypesListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<SourceType>> {
        const response = await this.sourcesOauthSourceTypesListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Source Viewset
     */
    async sourcesOauthUpdateRaw(requestParameters: SourcesOauthUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OAuthSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesOauthUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/oauth/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: OAuthSourceRequestToJSON(requestParameters['oAuthSourceRequest']),
        }, initOverrides);

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

    /**
     * Source Viewset
     */
    async sourcesOauthUpdate(requestParameters: SourcesOauthUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OAuthSource> {
        const response = await this.sourcesOauthUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesOauthUsedByListRaw(requestParameters: SourcesOauthUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesOauthUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/oauth/{slug}/used_by/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * Plex source Viewset
     */
    async sourcesPlexCreateRaw(requestParameters: SourcesPlexCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PlexSource>> {
        if (requestParameters['plexSourceRequest'] == null) {
            throw new runtime.RequiredError(
                'plexSourceRequest',
                'Required parameter "plexSourceRequest" was null or undefined when calling sourcesPlexCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/plex/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: PlexSourceRequestToJSON(requestParameters['plexSourceRequest']),
        }, initOverrides);

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

    /**
     * Plex source Viewset
     */
    async sourcesPlexCreate(requestParameters: SourcesPlexCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PlexSource> {
        const response = await this.sourcesPlexCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Plex source Viewset
     */
    async sourcesPlexDestroyRaw(requestParameters: SourcesPlexDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesPlexDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/plex/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Plex source Viewset
     */
    async sourcesPlexDestroy(requestParameters: SourcesPlexDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesPlexDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Plex source Viewset
     */
    async sourcesPlexListRaw(requestParameters: SourcesPlexListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedPlexSourceList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/plex/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Plex source Viewset
     */
    async sourcesPlexList(requestParameters: SourcesPlexListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedPlexSourceList> {
        const response = await this.sourcesPlexListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Plex source Viewset
     */
    async sourcesPlexPartialUpdateRaw(requestParameters: SourcesPlexPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PlexSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesPlexPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/plex/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedPlexSourceRequestToJSON(requestParameters['patchedPlexSourceRequest']),
        }, initOverrides);

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

    /**
     * Plex source Viewset
     */
    async sourcesPlexPartialUpdate(requestParameters: SourcesPlexPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PlexSource> {
        const response = await this.sourcesPlexPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Redeem a plex token for an authenticated user, creating a connection
     */
    async sourcesPlexRedeemTokenAuthenticatedCreateRaw(requestParameters: SourcesPlexRedeemTokenAuthenticatedCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['plexTokenRedeemRequest'] == null) {
            throw new runtime.RequiredError(
                'plexTokenRedeemRequest',
                'Required parameter "plexTokenRedeemRequest" was null or undefined when calling sourcesPlexRedeemTokenAuthenticatedCreate().'
            );
        }

        const queryParameters: any = {};

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/plex/redeem_token_authenticated/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: PlexTokenRedeemRequestToJSON(requestParameters['plexTokenRedeemRequest']),
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Redeem a plex token for an authenticated user, creating a connection
     */
    async sourcesPlexRedeemTokenAuthenticatedCreate(requestParameters: SourcesPlexRedeemTokenAuthenticatedCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesPlexRedeemTokenAuthenticatedCreateRaw(requestParameters, initOverrides);
    }

    /**
     * Redeem a plex token, check it\'s access to resources against what\'s allowed for the source, and redirect to an authentication/enrollment flow.
     */
    async sourcesPlexRedeemTokenCreateRaw(requestParameters: SourcesPlexRedeemTokenCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RedirectChallenge>> {
        if (requestParameters['plexTokenRedeemRequest'] == null) {
            throw new runtime.RequiredError(
                'plexTokenRedeemRequest',
                'Required parameter "plexTokenRedeemRequest" was null or undefined when calling sourcesPlexRedeemTokenCreate().'
            );
        }

        const queryParameters: any = {};

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/plex/redeem_token/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: PlexTokenRedeemRequestToJSON(requestParameters['plexTokenRedeemRequest']),
        }, initOverrides);

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

    /**
     * Redeem a plex token, check it\'s access to resources against what\'s allowed for the source, and redirect to an authentication/enrollment flow.
     */
    async sourcesPlexRedeemTokenCreate(requestParameters: SourcesPlexRedeemTokenCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RedirectChallenge> {
        const response = await this.sourcesPlexRedeemTokenCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Plex source Viewset
     */
    async sourcesPlexRetrieveRaw(requestParameters: SourcesPlexRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PlexSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesPlexRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/plex/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Plex source Viewset
     */
    async sourcesPlexRetrieve(requestParameters: SourcesPlexRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PlexSource> {
        const response = await this.sourcesPlexRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Plex source Viewset
     */
    async sourcesPlexUpdateRaw(requestParameters: SourcesPlexUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PlexSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesPlexUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/plex/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: PlexSourceRequestToJSON(requestParameters['plexSourceRequest']),
        }, initOverrides);

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

    /**
     * Plex source Viewset
     */
    async sourcesPlexUpdate(requestParameters: SourcesPlexUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PlexSource> {
        const response = await this.sourcesPlexUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesPlexUsedByListRaw(requestParameters: SourcesPlexUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesPlexUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/plex/{slug}/used_by/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlCreateRaw(requestParameters: SourcesSamlCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SAMLSource>> {
        if (requestParameters['sAMLSourceRequest'] == null) {
            throw new runtime.RequiredError(
                'sAMLSourceRequest',
                'Required parameter "sAMLSourceRequest" was null or undefined when calling sourcesSamlCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/saml/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SAMLSourceRequestToJSON(requestParameters['sAMLSourceRequest']),
        }, initOverrides);

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

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlCreate(requestParameters: SourcesSamlCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SAMLSource> {
        const response = await this.sourcesSamlCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlDestroyRaw(requestParameters: SourcesSamlDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesSamlDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/saml/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlDestroy(requestParameters: SourcesSamlDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesSamlDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlListRaw(requestParameters: SourcesSamlListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedSAMLSourceList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/saml/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlList(requestParameters: SourcesSamlListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedSAMLSourceList> {
        const response = await this.sourcesSamlListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Return metadata as XML string
     */
    async sourcesSamlMetadataRetrieveRaw(requestParameters: SourcesSamlMetadataRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SAMLMetadata>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesSamlMetadataRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/saml/{slug}/metadata/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * Return metadata as XML string
     */
    async sourcesSamlMetadataRetrieve(requestParameters: SourcesSamlMetadataRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SAMLMetadata> {
        const response = await this.sourcesSamlMetadataRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlPartialUpdateRaw(requestParameters: SourcesSamlPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SAMLSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesSamlPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/saml/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedSAMLSourceRequestToJSON(requestParameters['patchedSAMLSourceRequest']),
        }, initOverrides);

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

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlPartialUpdate(requestParameters: SourcesSamlPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SAMLSource> {
        const response = await this.sourcesSamlPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlRetrieveRaw(requestParameters: SourcesSamlRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SAMLSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesSamlRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/saml/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlRetrieve(requestParameters: SourcesSamlRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SAMLSource> {
        const response = await this.sourcesSamlRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlUpdateRaw(requestParameters: SourcesSamlUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SAMLSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesSamlUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/saml/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SAMLSourceRequestToJSON(requestParameters['sAMLSourceRequest']),
        }, initOverrides);

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

    /**
     * SAMLSource Viewset
     */
    async sourcesSamlUpdate(requestParameters: SourcesSamlUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SAMLSource> {
        const response = await this.sourcesSamlUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesSamlUsedByListRaw(requestParameters: SourcesSamlUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesSamlUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/saml/{slug}/used_by/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * SCIMSource Viewset
     */
    async sourcesScimCreateRaw(requestParameters: SourcesScimCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSource>> {
        if (requestParameters['sCIMSourceRequest'] == null) {
            throw new runtime.RequiredError(
                'sCIMSourceRequest',
                'Required parameter "sCIMSourceRequest" was null or undefined when calling sourcesScimCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SCIMSourceRequestToJSON(requestParameters['sCIMSourceRequest']),
        }, initOverrides);

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

    /**
     * SCIMSource Viewset
     */
    async sourcesScimCreate(requestParameters: SourcesScimCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSource> {
        const response = await this.sourcesScimCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSource Viewset
     */
    async sourcesScimDestroyRaw(requestParameters: SourcesScimDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesScimDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * SCIMSource Viewset
     */
    async sourcesScimDestroy(requestParameters: SourcesScimDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesScimDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsCreateRaw(requestParameters: SourcesScimGroupsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSourceGroup>> {
        if (requestParameters['sCIMSourceGroupRequest'] == null) {
            throw new runtime.RequiredError(
                'sCIMSourceGroupRequest',
                'Required parameter "sCIMSourceGroupRequest" was null or undefined when calling sourcesScimGroupsCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_groups/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SCIMSourceGroupRequestToJSON(requestParameters['sCIMSourceGroupRequest']),
        }, initOverrides);

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

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsCreate(requestParameters: SourcesScimGroupsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSourceGroup> {
        const response = await this.sourcesScimGroupsCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsDestroyRaw(requestParameters: SourcesScimGroupsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesScimGroupsDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_groups/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsDestroy(requestParameters: SourcesScimGroupsDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesScimGroupsDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsListRaw(requestParameters: SourcesScimGroupsListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedSCIMSourceGroupList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_groups/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsList(requestParameters: SourcesScimGroupsListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedSCIMSourceGroupList> {
        const response = await this.sourcesScimGroupsListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsPartialUpdateRaw(requestParameters: SourcesScimGroupsPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSourceGroup>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesScimGroupsPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_groups/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedSCIMSourceGroupRequestToJSON(requestParameters['patchedSCIMSourceGroupRequest']),
        }, initOverrides);

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

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsPartialUpdate(requestParameters: SourcesScimGroupsPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSourceGroup> {
        const response = await this.sourcesScimGroupsPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsRetrieveRaw(requestParameters: SourcesScimGroupsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSourceGroup>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesScimGroupsRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_groups/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsRetrieve(requestParameters: SourcesScimGroupsRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSourceGroup> {
        const response = await this.sourcesScimGroupsRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsUpdateRaw(requestParameters: SourcesScimGroupsUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSourceGroup>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesScimGroupsUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_groups/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SCIMSourceGroupRequestToJSON(requestParameters['sCIMSourceGroupRequest']),
        }, initOverrides);

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

    /**
     * SCIMSourceGroup Viewset
     */
    async sourcesScimGroupsUpdate(requestParameters: SourcesScimGroupsUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSourceGroup> {
        const response = await this.sourcesScimGroupsUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesScimGroupsUsedByListRaw(requestParameters: SourcesScimGroupsUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesScimGroupsUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_groups/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * SCIMSource Viewset
     */
    async sourcesScimListRaw(requestParameters: SourcesScimListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedSCIMSourceList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * SCIMSource Viewset
     */
    async sourcesScimList(requestParameters: SourcesScimListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedSCIMSourceList> {
        const response = await this.sourcesScimListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSource Viewset
     */
    async sourcesScimPartialUpdateRaw(requestParameters: SourcesScimPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesScimPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedSCIMSourceRequestToJSON(requestParameters['patchedSCIMSourceRequest']),
        }, initOverrides);

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

    /**
     * SCIMSource Viewset
     */
    async sourcesScimPartialUpdate(requestParameters: SourcesScimPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSource> {
        const response = await this.sourcesScimPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSource Viewset
     */
    async sourcesScimRetrieveRaw(requestParameters: SourcesScimRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesScimRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * SCIMSource Viewset
     */
    async sourcesScimRetrieve(requestParameters: SourcesScimRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSource> {
        const response = await this.sourcesScimRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSource Viewset
     */
    async sourcesScimUpdateRaw(requestParameters: SourcesScimUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSource>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesScimUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim/{slug}/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SCIMSourceRequestToJSON(requestParameters['sCIMSourceRequest']),
        }, initOverrides);

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

    /**
     * SCIMSource Viewset
     */
    async sourcesScimUpdate(requestParameters: SourcesScimUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSource> {
        const response = await this.sourcesScimUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesScimUsedByListRaw(requestParameters: SourcesScimUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['slug'] == null) {
            throw new runtime.RequiredError(
                'slug',
                'Required parameter "slug" was null or undefined when calling sourcesScimUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim/{slug}/used_by/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters['slug']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersCreateRaw(requestParameters: SourcesScimUsersCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSourceUser>> {
        if (requestParameters['sCIMSourceUserRequest'] == null) {
            throw new runtime.RequiredError(
                'sCIMSourceUserRequest',
                'Required parameter "sCIMSourceUserRequest" was null or undefined when calling sourcesScimUsersCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_users/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SCIMSourceUserRequestToJSON(requestParameters['sCIMSourceUserRequest']),
        }, initOverrides);

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

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersCreate(requestParameters: SourcesScimUsersCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSourceUser> {
        const response = await this.sourcesScimUsersCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersDestroyRaw(requestParameters: SourcesScimUsersDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesScimUsersDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_users/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersDestroy(requestParameters: SourcesScimUsersDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesScimUsersDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersListRaw(requestParameters: SourcesScimUsersListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedSCIMSourceUserList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_users/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersList(requestParameters: SourcesScimUsersListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedSCIMSourceUserList> {
        const response = await this.sourcesScimUsersListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersPartialUpdateRaw(requestParameters: SourcesScimUsersPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSourceUser>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesScimUsersPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_users/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedSCIMSourceUserRequestToJSON(requestParameters['patchedSCIMSourceUserRequest']),
        }, initOverrides);

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

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersPartialUpdate(requestParameters: SourcesScimUsersPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSourceUser> {
        const response = await this.sourcesScimUsersPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersRetrieveRaw(requestParameters: SourcesScimUsersRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSourceUser>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesScimUsersRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_users/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersRetrieve(requestParameters: SourcesScimUsersRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSourceUser> {
        const response = await this.sourcesScimUsersRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersUpdateRaw(requestParameters: SourcesScimUsersUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SCIMSourceUser>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesScimUsersUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_users/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SCIMSourceUserRequestToJSON(requestParameters['sCIMSourceUserRequest']),
        }, initOverrides);

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

    /**
     * SCIMSourceUser Viewset
     */
    async sourcesScimUsersUpdate(requestParameters: SourcesScimUsersUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SCIMSourceUser> {
        const response = await this.sourcesScimUsersUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesScimUsersUsedByListRaw(requestParameters: SourcesScimUsersUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesScimUsersUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/scim_users/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsAllDestroyRaw(requestParameters: SourcesUserConnectionsAllDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsAllDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/all/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsAllDestroy(requestParameters: SourcesUserConnectionsAllDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesUserConnectionsAllDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsAllListRaw(requestParameters: SourcesUserConnectionsAllListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedUserSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/all/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsAllList(requestParameters: SourcesUserConnectionsAllListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedUserSourceConnectionList> {
        const response = await this.sourcesUserConnectionsAllListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsAllPartialUpdateRaw(requestParameters: SourcesUserConnectionsAllPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsAllPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/all/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedUserSourceConnectionRequestToJSON(requestParameters['patchedUserSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsAllPartialUpdate(requestParameters: SourcesUserConnectionsAllPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSourceConnection> {
        const response = await this.sourcesUserConnectionsAllPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsAllRetrieveRaw(requestParameters: SourcesUserConnectionsAllRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsAllRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/all/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsAllRetrieve(requestParameters: SourcesUserConnectionsAllRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSourceConnection> {
        const response = await this.sourcesUserConnectionsAllRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsAllUpdateRaw(requestParameters: SourcesUserConnectionsAllUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsAllUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/all/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UserSourceConnectionRequestToJSON(requestParameters['userSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsAllUpdate(requestParameters: SourcesUserConnectionsAllUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSourceConnection> {
        const response = await this.sourcesUserConnectionsAllUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesUserConnectionsAllUsedByListRaw(requestParameters: SourcesUserConnectionsAllUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsAllUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/all/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosCreateRaw(requestParameters: SourcesUserConnectionsKerberosCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserKerberosSourceConnection>> {
        if (requestParameters['userKerberosSourceConnectionRequest'] == null) {
            throw new runtime.RequiredError(
                'userKerberosSourceConnectionRequest',
                'Required parameter "userKerberosSourceConnectionRequest" was null or undefined when calling sourcesUserConnectionsKerberosCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/kerberos/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UserKerberosSourceConnectionRequestToJSON(requestParameters['userKerberosSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosCreate(requestParameters: SourcesUserConnectionsKerberosCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserKerberosSourceConnection> {
        const response = await this.sourcesUserConnectionsKerberosCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosDestroyRaw(requestParameters: SourcesUserConnectionsKerberosDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsKerberosDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/kerberos/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosDestroy(requestParameters: SourcesUserConnectionsKerberosDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesUserConnectionsKerberosDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosListRaw(requestParameters: SourcesUserConnectionsKerberosListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedUserKerberosSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/kerberos/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosList(requestParameters: SourcesUserConnectionsKerberosListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedUserKerberosSourceConnectionList> {
        const response = await this.sourcesUserConnectionsKerberosListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosPartialUpdateRaw(requestParameters: SourcesUserConnectionsKerberosPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserKerberosSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsKerberosPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/kerberos/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedUserKerberosSourceConnectionRequestToJSON(requestParameters['patchedUserKerberosSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosPartialUpdate(requestParameters: SourcesUserConnectionsKerberosPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserKerberosSourceConnection> {
        const response = await this.sourcesUserConnectionsKerberosPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosRetrieveRaw(requestParameters: SourcesUserConnectionsKerberosRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserKerberosSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsKerberosRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/kerberos/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosRetrieve(requestParameters: SourcesUserConnectionsKerberosRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserKerberosSourceConnection> {
        const response = await this.sourcesUserConnectionsKerberosRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosUpdateRaw(requestParameters: SourcesUserConnectionsKerberosUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserKerberosSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsKerberosUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/kerberos/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UserKerberosSourceConnectionRequestToJSON(requestParameters['userKerberosSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsKerberosUpdate(requestParameters: SourcesUserConnectionsKerberosUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserKerberosSourceConnection> {
        const response = await this.sourcesUserConnectionsKerberosUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesUserConnectionsKerberosUsedByListRaw(requestParameters: SourcesUserConnectionsKerberosUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsKerberosUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/kerberos/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapCreateRaw(requestParameters: SourcesUserConnectionsLdapCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserLDAPSourceConnection>> {
        if (requestParameters['userLDAPSourceConnectionRequest'] == null) {
            throw new runtime.RequiredError(
                'userLDAPSourceConnectionRequest',
                'Required parameter "userLDAPSourceConnectionRequest" was null or undefined when calling sourcesUserConnectionsLdapCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/ldap/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UserLDAPSourceConnectionRequestToJSON(requestParameters['userLDAPSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapCreate(requestParameters: SourcesUserConnectionsLdapCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserLDAPSourceConnection> {
        const response = await this.sourcesUserConnectionsLdapCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapDestroyRaw(requestParameters: SourcesUserConnectionsLdapDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsLdapDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/ldap/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapDestroy(requestParameters: SourcesUserConnectionsLdapDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesUserConnectionsLdapDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapListRaw(requestParameters: SourcesUserConnectionsLdapListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedUserLDAPSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/ldap/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapList(requestParameters: SourcesUserConnectionsLdapListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedUserLDAPSourceConnectionList> {
        const response = await this.sourcesUserConnectionsLdapListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapPartialUpdateRaw(requestParameters: SourcesUserConnectionsLdapPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserLDAPSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsLdapPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/ldap/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedUserLDAPSourceConnectionRequestToJSON(requestParameters['patchedUserLDAPSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapPartialUpdate(requestParameters: SourcesUserConnectionsLdapPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserLDAPSourceConnection> {
        const response = await this.sourcesUserConnectionsLdapPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapRetrieveRaw(requestParameters: SourcesUserConnectionsLdapRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserLDAPSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsLdapRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/ldap/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapRetrieve(requestParameters: SourcesUserConnectionsLdapRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserLDAPSourceConnection> {
        const response = await this.sourcesUserConnectionsLdapRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapUpdateRaw(requestParameters: SourcesUserConnectionsLdapUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserLDAPSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsLdapUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/ldap/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UserLDAPSourceConnectionRequestToJSON(requestParameters['userLDAPSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsLdapUpdate(requestParameters: SourcesUserConnectionsLdapUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserLDAPSourceConnection> {
        const response = await this.sourcesUserConnectionsLdapUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesUserConnectionsLdapUsedByListRaw(requestParameters: SourcesUserConnectionsLdapUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsLdapUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/ldap/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthCreateRaw(requestParameters: SourcesUserConnectionsOauthCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserOAuthSourceConnection>> {
        if (requestParameters['userOAuthSourceConnectionRequest'] == null) {
            throw new runtime.RequiredError(
                'userOAuthSourceConnectionRequest',
                'Required parameter "userOAuthSourceConnectionRequest" was null or undefined when calling sourcesUserConnectionsOauthCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/oauth/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UserOAuthSourceConnectionRequestToJSON(requestParameters['userOAuthSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthCreate(requestParameters: SourcesUserConnectionsOauthCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserOAuthSourceConnection> {
        const response = await this.sourcesUserConnectionsOauthCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthDestroyRaw(requestParameters: SourcesUserConnectionsOauthDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsOauthDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthDestroy(requestParameters: SourcesUserConnectionsOauthDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesUserConnectionsOauthDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthListRaw(requestParameters: SourcesUserConnectionsOauthListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedUserOAuthSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/oauth/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthList(requestParameters: SourcesUserConnectionsOauthListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedUserOAuthSourceConnectionList> {
        const response = await this.sourcesUserConnectionsOauthListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthPartialUpdateRaw(requestParameters: SourcesUserConnectionsOauthPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserOAuthSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsOauthPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedUserOAuthSourceConnectionRequestToJSON(requestParameters['patchedUserOAuthSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthPartialUpdate(requestParameters: SourcesUserConnectionsOauthPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserOAuthSourceConnection> {
        const response = await this.sourcesUserConnectionsOauthPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthRetrieveRaw(requestParameters: SourcesUserConnectionsOauthRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserOAuthSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsOauthRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthRetrieve(requestParameters: SourcesUserConnectionsOauthRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserOAuthSourceConnection> {
        const response = await this.sourcesUserConnectionsOauthRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthUpdateRaw(requestParameters: SourcesUserConnectionsOauthUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserOAuthSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsOauthUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UserOAuthSourceConnectionRequestToJSON(requestParameters['userOAuthSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsOauthUpdate(requestParameters: SourcesUserConnectionsOauthUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserOAuthSourceConnection> {
        const response = await this.sourcesUserConnectionsOauthUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesUserConnectionsOauthUsedByListRaw(requestParameters: SourcesUserConnectionsOauthUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsOauthUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/oauth/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexCreateRaw(requestParameters: SourcesUserConnectionsPlexCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserPlexSourceConnection>> {
        if (requestParameters['userPlexSourceConnectionRequest'] == null) {
            throw new runtime.RequiredError(
                'userPlexSourceConnectionRequest',
                'Required parameter "userPlexSourceConnectionRequest" was null or undefined when calling sourcesUserConnectionsPlexCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/plex/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UserPlexSourceConnectionRequestToJSON(requestParameters['userPlexSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexCreate(requestParameters: SourcesUserConnectionsPlexCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserPlexSourceConnection> {
        const response = await this.sourcesUserConnectionsPlexCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexDestroyRaw(requestParameters: SourcesUserConnectionsPlexDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsPlexDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexDestroy(requestParameters: SourcesUserConnectionsPlexDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesUserConnectionsPlexDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexListRaw(requestParameters: SourcesUserConnectionsPlexListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedUserPlexSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/plex/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexList(requestParameters: SourcesUserConnectionsPlexListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedUserPlexSourceConnectionList> {
        const response = await this.sourcesUserConnectionsPlexListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexPartialUpdateRaw(requestParameters: SourcesUserConnectionsPlexPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserPlexSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsPlexPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedUserPlexSourceConnectionRequestToJSON(requestParameters['patchedUserPlexSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexPartialUpdate(requestParameters: SourcesUserConnectionsPlexPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserPlexSourceConnection> {
        const response = await this.sourcesUserConnectionsPlexPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexRetrieveRaw(requestParameters: SourcesUserConnectionsPlexRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserPlexSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsPlexRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexRetrieve(requestParameters: SourcesUserConnectionsPlexRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserPlexSourceConnection> {
        const response = await this.sourcesUserConnectionsPlexRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexUpdateRaw(requestParameters: SourcesUserConnectionsPlexUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserPlexSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsPlexUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UserPlexSourceConnectionRequestToJSON(requestParameters['userPlexSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsPlexUpdate(requestParameters: SourcesUserConnectionsPlexUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserPlexSourceConnection> {
        const response = await this.sourcesUserConnectionsPlexUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesUserConnectionsPlexUsedByListRaw(requestParameters: SourcesUserConnectionsPlexUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsPlexUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/plex/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlCreateRaw(requestParameters: SourcesUserConnectionsSamlCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSAMLSourceConnection>> {
        if (requestParameters['userSAMLSourceConnectionRequest'] == null) {
            throw new runtime.RequiredError(
                'userSAMLSourceConnectionRequest',
                'Required parameter "userSAMLSourceConnectionRequest" was null or undefined when calling sourcesUserConnectionsSamlCreate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/saml/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UserSAMLSourceConnectionRequestToJSON(requestParameters['userSAMLSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlCreate(requestParameters: SourcesUserConnectionsSamlCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSAMLSourceConnection> {
        const response = await this.sourcesUserConnectionsSamlCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlDestroyRaw(requestParameters: SourcesUserConnectionsSamlDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsSamlDestroy().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/saml/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlDestroy(requestParameters: SourcesUserConnectionsSamlDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sourcesUserConnectionsSamlDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlListRaw(requestParameters: SourcesUserConnectionsSamlListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedUserSAMLSourceConnectionList>> {
        const queryParameters: any = {};

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/saml/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlList(requestParameters: SourcesUserConnectionsSamlListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedUserSAMLSourceConnectionList> {
        const response = await this.sourcesUserConnectionsSamlListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlPartialUpdateRaw(requestParameters: SourcesUserConnectionsSamlPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSAMLSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsSamlPartialUpdate().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/saml/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedUserSAMLSourceConnectionRequestToJSON(requestParameters['patchedUserSAMLSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlPartialUpdate(requestParameters: SourcesUserConnectionsSamlPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSAMLSourceConnection> {
        const response = await this.sourcesUserConnectionsSamlPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlRetrieveRaw(requestParameters: SourcesUserConnectionsSamlRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSAMLSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsSamlRetrieve().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/saml/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlRetrieve(requestParameters: SourcesUserConnectionsSamlRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSAMLSourceConnection> {
        const response = await this.sourcesUserConnectionsSamlRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlUpdateRaw(requestParameters: SourcesUserConnectionsSamlUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSAMLSourceConnection>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsSamlUpdate().'
            );
        }

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

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/saml/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UserSAMLSourceConnectionRequestToJSON(requestParameters['userSAMLSourceConnectionRequest']),
        }, initOverrides);

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

    /**
     * User-source connection Viewset
     */
    async sourcesUserConnectionsSamlUpdate(requestParameters: SourcesUserConnectionsSamlUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSAMLSourceConnection> {
        const response = await this.sourcesUserConnectionsSamlUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get a list of all objects that use this object
     */
    async sourcesUserConnectionsSamlUsedByListRaw(requestParameters: SourcesUserConnectionsSamlUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
        if (requestParameters['id'] == null) {
            throw new runtime.RequiredError(
                'id',
                'Required parameter "id" was null or undefined when calling sourcesUserConnectionsSamlUsedByList().'
            );
        }

        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}`;
            }
        }
        const response = await this.request({
            path: `/sources/user_connections/saml/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

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

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

}

/**
 * @export
 */
export const SourcesKerberosListKadminTypeEnum = {
    Heimdal: 'Heimdal',
    Mit: 'MIT',
    Other: 'other',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesKerberosListKadminTypeEnum = typeof SourcesKerberosListKadminTypeEnum[keyof typeof SourcesKerberosListKadminTypeEnum];
/**
 * @export
 */
export const SourcesOauthListGroupMatchingModeEnum = {
    Identifier: 'identifier',
    NameDeny: 'name_deny',
    NameLink: 'name_link',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesOauthListGroupMatchingModeEnum = typeof SourcesOauthListGroupMatchingModeEnum[keyof typeof SourcesOauthListGroupMatchingModeEnum];
/**
 * @export
 */
export const SourcesOauthListPolicyEngineModeEnum = {
    All: 'all',
    Any: 'any',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesOauthListPolicyEngineModeEnum = typeof SourcesOauthListPolicyEngineModeEnum[keyof typeof SourcesOauthListPolicyEngineModeEnum];
/**
 * @export
 */
export const SourcesOauthListUserMatchingModeEnum = {
    EmailDeny: 'email_deny',
    EmailLink: 'email_link',
    Identifier: 'identifier',
    UsernameDeny: 'username_deny',
    UsernameLink: 'username_link',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesOauthListUserMatchingModeEnum = typeof SourcesOauthListUserMatchingModeEnum[keyof typeof SourcesOauthListUserMatchingModeEnum];
/**
 * @export
 */
export const SourcesPlexListGroupMatchingModeEnum = {
    Identifier: 'identifier',
    NameDeny: 'name_deny',
    NameLink: 'name_link',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesPlexListGroupMatchingModeEnum = typeof SourcesPlexListGroupMatchingModeEnum[keyof typeof SourcesPlexListGroupMatchingModeEnum];
/**
 * @export
 */
export const SourcesPlexListPolicyEngineModeEnum = {
    All: 'all',
    Any: 'any',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesPlexListPolicyEngineModeEnum = typeof SourcesPlexListPolicyEngineModeEnum[keyof typeof SourcesPlexListPolicyEngineModeEnum];
/**
 * @export
 */
export const SourcesPlexListUserMatchingModeEnum = {
    EmailDeny: 'email_deny',
    EmailLink: 'email_link',
    Identifier: 'identifier',
    UsernameDeny: 'username_deny',
    UsernameLink: 'username_link',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesPlexListUserMatchingModeEnum = typeof SourcesPlexListUserMatchingModeEnum[keyof typeof SourcesPlexListUserMatchingModeEnum];
/**
 * @export
 */
export const SourcesSamlListBindingTypeEnum = {
    Post: 'POST',
    PostAuto: 'POST_AUTO',
    Redirect: 'REDIRECT',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesSamlListBindingTypeEnum = typeof SourcesSamlListBindingTypeEnum[keyof typeof SourcesSamlListBindingTypeEnum];
/**
 * @export
 */
export const SourcesSamlListDigestAlgorithmEnum = {
    HttpWwwW3Org200009Xmldsigsha1: 'http://www.w3.org/2000/09/xmldsig#sha1',
    HttpWwwW3Org200104XmldsigMoresha384: 'http://www.w3.org/2001/04/xmldsig-more#sha384',
    HttpWwwW3Org200104Xmlencsha256: 'http://www.w3.org/2001/04/xmlenc#sha256',
    HttpWwwW3Org200104Xmlencsha512: 'http://www.w3.org/2001/04/xmlenc#sha512',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesSamlListDigestAlgorithmEnum = typeof SourcesSamlListDigestAlgorithmEnum[keyof typeof SourcesSamlListDigestAlgorithmEnum];
/**
 * @export
 */
export const SourcesSamlListNameIdPolicyEnum = {
    UrnOasisNamesTcSaml11NameidFormatX509SubjectName: 'urn:oasis:names:tc:SAML:1.1:nameid-format:X509SubjectName',
    UrnOasisNamesTcSaml11NameidFormatEmailAddress: 'urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress',
    UrnOasisNamesTcSaml20NameidFormatWindowsDomainQualifiedName: 'urn:oasis:names:tc:SAML:2.0:nameid-format:WindowsDomainQualifiedName',
    UrnOasisNamesTcSaml20NameidFormatPersistent: 'urn:oasis:names:tc:SAML:2.0:nameid-format:persistent',
    UrnOasisNamesTcSaml20NameidFormatTransient: 'urn:oasis:names:tc:SAML:2.0:nameid-format:transient',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesSamlListNameIdPolicyEnum = typeof SourcesSamlListNameIdPolicyEnum[keyof typeof SourcesSamlListNameIdPolicyEnum];
/**
 * @export
 */
export const SourcesSamlListPolicyEngineModeEnum = {
    All: 'all',
    Any: 'any',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesSamlListPolicyEngineModeEnum = typeof SourcesSamlListPolicyEngineModeEnum[keyof typeof SourcesSamlListPolicyEngineModeEnum];
/**
 * @export
 */
export const SourcesSamlListSignatureAlgorithmEnum = {
    HttpWwwW3Org200009XmldsigdsaSha1: 'http://www.w3.org/2000/09/xmldsig#dsa-sha1',
    HttpWwwW3Org200009XmldsigrsaSha1: 'http://www.w3.org/2000/09/xmldsig#rsa-sha1',
    HttpWwwW3Org200104XmldsigMoreecdsaSha1: 'http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha1',
    HttpWwwW3Org200104XmldsigMoreecdsaSha256: 'http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256',
    HttpWwwW3Org200104XmldsigMoreecdsaSha384: 'http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha384',
    HttpWwwW3Org200104XmldsigMoreecdsaSha512: 'http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha512',
    HttpWwwW3Org200104XmldsigMorersaSha256: 'http://www.w3.org/2001/04/xmldsig-more#rsa-sha256',
    HttpWwwW3Org200104XmldsigMorersaSha384: 'http://www.w3.org/2001/04/xmldsig-more#rsa-sha384',
    HttpWwwW3Org200104XmldsigMorersaSha512: 'http://www.w3.org/2001/04/xmldsig-more#rsa-sha512',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesSamlListSignatureAlgorithmEnum = typeof SourcesSamlListSignatureAlgorithmEnum[keyof typeof SourcesSamlListSignatureAlgorithmEnum];
/**
 * @export
 */
export const SourcesSamlListUserMatchingModeEnum = {
    EmailDeny: 'email_deny',
    EmailLink: 'email_link',
    Identifier: 'identifier',
    UsernameDeny: 'username_deny',
    UsernameLink: 'username_link',
    UnknownDefaultOpenApi: '11184809'
} as const;
export type SourcesSamlListUserMatchingModeEnum = typeof SourcesSamlListUserMatchingModeEnum[keyof typeof SourcesSamlListUserMatchingModeEnum];