@goauthentik/api 2024.8.3-1729630021 → 2024.8.3-1729699127

package/src/apis/SourcesApi.ts

@@ -17,17 +17,23 @@ import * as runtime from '../runtime';
 import type {
   FilePathRequest,
   GenericError,
+  GroupKerberosSourceConnection,
   GroupOAuthSourceConnection,
   GroupPlexSourceConnection,
   GroupSAMLSourceConnection,
+  KerberosSource,
+  KerberosSourceRequest,
+  KerberosSyncStatus,
   LDAPDebug,
   LDAPSource,
   LDAPSourceRequest,
   OAuthSource,
   OAuthSourceRequest,
+  PaginatedGroupKerberosSourceConnectionList,
   PaginatedGroupOAuthSourceConnectionList,
   PaginatedGroupPlexSourceConnectionList,
   PaginatedGroupSAMLSourceConnectionList,
+  PaginatedKerberosSourceList,
   PaginatedLDAPSourceList,
   PaginatedOAuthSourceList,
   PaginatedPlexSourceList,
@@ -36,10 +42,12 @@ import type {
   PaginatedSCIMSourceList,
   PaginatedSCIMSourceUserList,
   PaginatedSourceList,
+  PaginatedUserKerberosSourceConnectionList,
   PaginatedUserOAuthSourceConnectionList,
   PaginatedUserPlexSourceConnectionList,
   PaginatedUserSAMLSourceConnectionList,
   PaginatedUserSourceConnectionList,
+  PatchedKerberosSourceRequest,
   PatchedLDAPSourceRequest,
   PatchedOAuthSourceRequest,
   PatchedPlexSourceRequest,
@@ -47,6 +55,7 @@ import type {
   PatchedSCIMSourceGroupRequest,
   PatchedSCIMSourceRequest,
   PatchedSCIMSourceUserRequest,
+  PatchedUserKerberosSourceConnectionRequest,
   PatchedUserOAuthSourceConnectionRequest,
   PatchedUserPlexSourceConnectionRequest,
   PatchedUserSAMLSourceConnectionRequest,
@@ -68,6 +77,8 @@ import type {
   SyncStatus,
   TypeCreate,
   UsedBy,
+  UserKerberosSourceConnection,
+  UserKerberosSourceConnectionRequest,
   UserOAuthSourceConnection,
   UserOAuthSourceConnectionRequest,
   UserPlexSourceConnection,
@@ -83,12 +94,20 @@ import {
     FilePathRequestToJSON,
     GenericErrorFromJSON,
     GenericErrorToJSON,
+    GroupKerberosSourceConnectionFromJSON,
+    GroupKerberosSourceConnectionToJSON,
     GroupOAuthSourceConnectionFromJSON,
     GroupOAuthSourceConnectionToJSON,
     GroupPlexSourceConnectionFromJSON,
     GroupPlexSourceConnectionToJSON,
     GroupSAMLSourceConnectionFromJSON,
     GroupSAMLSourceConnectionToJSON,
+    KerberosSourceFromJSON,
+    KerberosSourceToJSON,
+    KerberosSourceRequestFromJSON,
+    KerberosSourceRequestToJSON,
+    KerberosSyncStatusFromJSON,
+    KerberosSyncStatusToJSON,
     LDAPDebugFromJSON,
     LDAPDebugToJSON,
     LDAPSourceFromJSON,
@@ -99,12 +118,16 @@ import {
     OAuthSourceToJSON,
     OAuthSourceRequestFromJSON,
     OAuthSourceRequestToJSON,
+    PaginatedGroupKerberosSourceConnectionListFromJSON,
+    PaginatedGroupKerberosSourceConnectionListToJSON,
     PaginatedGroupOAuthSourceConnectionListFromJSON,
     PaginatedGroupOAuthSourceConnectionListToJSON,
     PaginatedGroupPlexSourceConnectionListFromJSON,
     PaginatedGroupPlexSourceConnectionListToJSON,
     PaginatedGroupSAMLSourceConnectionListFromJSON,
     PaginatedGroupSAMLSourceConnectionListToJSON,
+    PaginatedKerberosSourceListFromJSON,
+    PaginatedKerberosSourceListToJSON,
     PaginatedLDAPSourceListFromJSON,
     PaginatedLDAPSourceListToJSON,
     PaginatedOAuthSourceListFromJSON,
@@ -121,6 +144,8 @@ import {
     PaginatedSCIMSourceUserListToJSON,
     PaginatedSourceListFromJSON,
     PaginatedSourceListToJSON,
+    PaginatedUserKerberosSourceConnectionListFromJSON,
+    PaginatedUserKerberosSourceConnectionListToJSON,
     PaginatedUserOAuthSourceConnectionListFromJSON,
     PaginatedUserOAuthSourceConnectionListToJSON,
     PaginatedUserPlexSourceConnectionListFromJSON,
@@ -129,6 +154,8 @@ import {
     PaginatedUserSAMLSourceConnectionListToJSON,
     PaginatedUserSourceConnectionListFromJSON,
     PaginatedUserSourceConnectionListToJSON,
+    PatchedKerberosSourceRequestFromJSON,
+    PatchedKerberosSourceRequestToJSON,
     PatchedLDAPSourceRequestFromJSON,
     PatchedLDAPSourceRequestToJSON,
     PatchedOAuthSourceRequestFromJSON,
@@ -143,6 +170,8 @@ import {
     PatchedSCIMSourceRequestToJSON,
     PatchedSCIMSourceUserRequestFromJSON,
     PatchedSCIMSourceUserRequestToJSON,
+    PatchedUserKerberosSourceConnectionRequestFromJSON,
+    PatchedUserKerberosSourceConnectionRequestToJSON,
     PatchedUserOAuthSourceConnectionRequestFromJSON,
     PatchedUserOAuthSourceConnectionRequestToJSON,
     PatchedUserPlexSourceConnectionRequestFromJSON,
@@ -185,6 +214,10 @@ import {
     TypeCreateToJSON,
     UsedByFromJSON,
     UsedByToJSON,
+    UserKerberosSourceConnectionFromJSON,
+    UserKerberosSourceConnectionToJSON,
+    UserKerberosSourceConnectionRequestFromJSON,
+    UserKerberosSourceConnectionRequestToJSON,
     UserOAuthSourceConnectionFromJSON,
     UserOAuthSourceConnectionToJSON,
     UserOAuthSourceConnectionRequestFromJSON,
@@ -238,6 +271,35 @@ export interface SourcesAllUsedByListRequest {
     slug: string;
 }
 
+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;
+}
+
+export interface SourcesGroupConnectionsKerberosRetrieveRequest {
+    id: number;
+}
+
+export interface SourcesGroupConnectionsKerberosUpdateRequest {
+    id: number;
+}
+
+export interface SourcesGroupConnectionsKerberosUsedByListRequest {
+    id: number;
+}
+
 export interface SourcesGroupConnectionsOauthDestroyRequest {
     id: number;
 }
@@ -325,6 +387,52 @@ export interface SourcesGroupConnectionsSamlUsedByListRequest {
     id: number;
 }
 
+export interface SourcesKerberosCreateRequest {
+    kerberosSourceRequest: KerberosSourceRequest;
+}
+
+export interface SourcesKerberosDestroyRequest {
+    slug: string;
+}
+
+export interface SourcesKerberosListRequest {
+    enabled?: boolean;
+    name?: string;
+    ordering?: string;
+    page?: number;
+    pageSize?: number;
+    passwordLoginUpdateInternalPassword?: boolean;
+    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;
 }
@@ -688,6 +796,40 @@ 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;
+}
+
+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 SourcesUserConnectionsOauthCreateRequest {
     userOAuthSourceConnectionRequest: UserOAuthSourceConnectionRequest;
 }
@@ -1150,43 +1292,9 @@ export class SourcesApi extends runtime.BaseAPI {
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsOauthCreateRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
-        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/`,
-            method: 'POST',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-
-        return new runtime.JSONApiResponse(response, (jsonValue) => GroupOAuthSourceConnectionFromJSON(jsonValue));
-    }
-
-    /**
-     * Group-source connection Viewset
-     */
-    async sourcesGroupConnectionsOauthCreate(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupOAuthSourceConnection> {
-        const response = await this.sourcesGroupConnectionsOauthCreateRaw(initOverrides);
-        return await response.value();
-    }
-
-    /**
-     * Group-source connection Viewset
-     */
-    async sourcesGroupConnectionsOauthDestroyRaw(requestParameters: SourcesGroupConnectionsOauthDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async sourcesGroupConnectionsKerberosDestroyRaw(requestParameters: SourcesGroupConnectionsKerberosDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsOauthDestroy.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsKerberosDestroy.');
         }
 
         const queryParameters: any = {};
@@ -1202,7 +1310,7 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/sources/group_connections/kerberos/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -1214,14 +1322,14 @@ export class SourcesApi extends runtime.BaseAPI {
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsOauthDestroy(requestParameters: SourcesGroupConnectionsOauthDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.sourcesGroupConnectionsOauthDestroyRaw(requestParameters, initOverrides);
+    async sourcesGroupConnectionsKerberosDestroy(requestParameters: SourcesGroupConnectionsKerberosDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.sourcesGroupConnectionsKerberosDestroyRaw(requestParameters, initOverrides);
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsOauthListRaw(requestParameters: SourcesGroupConnectionsOauthListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGroupOAuthSourceConnectionList>> {
+    async sourcesGroupConnectionsKerberosListRaw(requestParameters: SourcesGroupConnectionsKerberosListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGroupKerberosSourceConnectionList>> {
         const queryParameters: any = {};
 
         if (requestParameters.group !== undefined) {
@@ -1259,29 +1367,29 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/oauth/`,
+            path: `/sources/group_connections/kerberos/`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedGroupOAuthSourceConnectionListFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedGroupKerberosSourceConnectionListFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsOauthList(requestParameters: SourcesGroupConnectionsOauthListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedGroupOAuthSourceConnectionList> {
-        const response = await this.sourcesGroupConnectionsOauthListRaw(requestParameters, initOverrides);
+    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 sourcesGroupConnectionsOauthPartialUpdateRaw(requestParameters: SourcesGroupConnectionsOauthPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
+    async sourcesGroupConnectionsKerberosPartialUpdateRaw(requestParameters: SourcesGroupConnectionsKerberosPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupKerberosSourceConnection>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsOauthPartialUpdate.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsKerberosPartialUpdate.');
         }
 
         const queryParameters: any = {};
@@ -1297,29 +1405,29 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/sources/group_connections/kerberos/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GroupOAuthSourceConnectionFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GroupKerberosSourceConnectionFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsOauthPartialUpdate(requestParameters: SourcesGroupConnectionsOauthPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupOAuthSourceConnection> {
-        const response = await this.sourcesGroupConnectionsOauthPartialUpdateRaw(requestParameters, initOverrides);
+    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 sourcesGroupConnectionsOauthRetrieveRaw(requestParameters: SourcesGroupConnectionsOauthRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
+    async sourcesGroupConnectionsKerberosRetrieveRaw(requestParameters: SourcesGroupConnectionsKerberosRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupKerberosSourceConnection>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsOauthRetrieve.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsKerberosRetrieve.');
         }
 
         const queryParameters: any = {};
@@ -1335,29 +1443,29 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            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) => GroupOAuthSourceConnectionFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GroupKerberosSourceConnectionFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsOauthRetrieve(requestParameters: SourcesGroupConnectionsOauthRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupOAuthSourceConnection> {
-        const response = await this.sourcesGroupConnectionsOauthRetrieveRaw(requestParameters, initOverrides);
+    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 sourcesGroupConnectionsOauthUpdateRaw(requestParameters: SourcesGroupConnectionsOauthUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
+    async sourcesGroupConnectionsKerberosUpdateRaw(requestParameters: SourcesGroupConnectionsKerberosUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupKerberosSourceConnection>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsOauthUpdate.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsKerberosUpdate.');
         }
 
         const queryParameters: any = {};
@@ -1373,29 +1481,29 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/sources/group_connections/kerberos/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GroupOAuthSourceConnectionFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GroupKerberosSourceConnectionFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsOauthUpdate(requestParameters: SourcesGroupConnectionsOauthUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupOAuthSourceConnection> {
-        const response = await this.sourcesGroupConnectionsOauthUpdateRaw(requestParameters, initOverrides);
+    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 sourcesGroupConnectionsOauthUsedByListRaw(requestParameters: SourcesGroupConnectionsOauthUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
+    async sourcesGroupConnectionsKerberosUsedByListRaw(requestParameters: SourcesGroupConnectionsKerberosUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsOauthUsedByList.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsKerberosUsedByList.');
         }
 
         const queryParameters: any = {};
@@ -1411,7 +1519,7 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/oauth/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/sources/group_connections/kerberos/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -1423,15 +1531,15 @@ export class SourcesApi extends runtime.BaseAPI {
     /**
      * 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);
+    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 sourcesGroupConnectionsPlexCreateRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupPlexSourceConnection>> {
+    async sourcesGroupConnectionsOauthCreateRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -1445,29 +1553,29 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/plex/`,
+            path: `/sources/group_connections/oauth/`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GroupPlexSourceConnectionFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GroupOAuthSourceConnectionFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsPlexCreate(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupPlexSourceConnection> {
-        const response = await this.sourcesGroupConnectionsPlexCreateRaw(initOverrides);
+    async sourcesGroupConnectionsOauthCreate(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupOAuthSourceConnection> {
+        const response = await this.sourcesGroupConnectionsOauthCreateRaw(initOverrides);
         return await response.value();
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsPlexDestroyRaw(requestParameters: SourcesGroupConnectionsPlexDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async sourcesGroupConnectionsOauthDestroyRaw(requestParameters: SourcesGroupConnectionsOauthDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsPlexDestroy.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsOauthDestroy.');
         }
 
         const queryParameters: any = {};
@@ -1483,7 +1591,7 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/sources/group_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -1495,14 +1603,14 @@ export class SourcesApi extends runtime.BaseAPI {
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsPlexDestroy(requestParameters: SourcesGroupConnectionsPlexDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.sourcesGroupConnectionsPlexDestroyRaw(requestParameters, initOverrides);
+    async sourcesGroupConnectionsOauthDestroy(requestParameters: SourcesGroupConnectionsOauthDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.sourcesGroupConnectionsOauthDestroyRaw(requestParameters, initOverrides);
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsPlexListRaw(requestParameters: SourcesGroupConnectionsPlexListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGroupPlexSourceConnectionList>> {
+    async sourcesGroupConnectionsOauthListRaw(requestParameters: SourcesGroupConnectionsOauthListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGroupOAuthSourceConnectionList>> {
         const queryParameters: any = {};
 
         if (requestParameters.group !== undefined) {
@@ -1540,29 +1648,29 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/plex/`,
+            path: `/sources/group_connections/oauth/`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedGroupPlexSourceConnectionListFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedGroupOAuthSourceConnectionListFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsPlexList(requestParameters: SourcesGroupConnectionsPlexListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedGroupPlexSourceConnectionList> {
-        const response = await this.sourcesGroupConnectionsPlexListRaw(requestParameters, initOverrides);
+    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 sourcesGroupConnectionsPlexPartialUpdateRaw(requestParameters: SourcesGroupConnectionsPlexPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupPlexSourceConnection>> {
+    async sourcesGroupConnectionsOauthPartialUpdateRaw(requestParameters: SourcesGroupConnectionsOauthPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsPlexPartialUpdate.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsOauthPartialUpdate.');
         }
 
         const queryParameters: any = {};
@@ -1578,29 +1686,29 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/sources/group_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GroupPlexSourceConnectionFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GroupOAuthSourceConnectionFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsPlexPartialUpdate(requestParameters: SourcesGroupConnectionsPlexPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupPlexSourceConnection> {
-        const response = await this.sourcesGroupConnectionsPlexPartialUpdateRaw(requestParameters, initOverrides);
+    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 sourcesGroupConnectionsPlexRetrieveRaw(requestParameters: SourcesGroupConnectionsPlexRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupPlexSourceConnection>> {
+    async sourcesGroupConnectionsOauthRetrieveRaw(requestParameters: SourcesGroupConnectionsOauthRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsPlexRetrieve.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsOauthRetrieve.');
         }
 
         const queryParameters: any = {};
@@ -1616,29 +1724,29 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            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) => GroupPlexSourceConnectionFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GroupOAuthSourceConnectionFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsPlexRetrieve(requestParameters: SourcesGroupConnectionsPlexRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupPlexSourceConnection> {
-        const response = await this.sourcesGroupConnectionsPlexRetrieveRaw(requestParameters, initOverrides);
+    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 sourcesGroupConnectionsPlexUpdateRaw(requestParameters: SourcesGroupConnectionsPlexUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupPlexSourceConnection>> {
+    async sourcesGroupConnectionsOauthUpdateRaw(requestParameters: SourcesGroupConnectionsOauthUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupOAuthSourceConnection>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsPlexUpdate.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsOauthUpdate.');
         }
 
         const queryParameters: any = {};
@@ -1654,29 +1762,29 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/sources/group_connections/oauth/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GroupPlexSourceConnectionFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GroupOAuthSourceConnectionFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsPlexUpdate(requestParameters: SourcesGroupConnectionsPlexUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupPlexSourceConnection> {
-        const response = await this.sourcesGroupConnectionsPlexUpdateRaw(requestParameters, initOverrides);
+    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 sourcesGroupConnectionsPlexUsedByListRaw(requestParameters: SourcesGroupConnectionsPlexUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
+    async sourcesGroupConnectionsOauthUsedByListRaw(requestParameters: SourcesGroupConnectionsOauthUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsPlexUsedByList.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsOauthUsedByList.');
         }
 
         const queryParameters: any = {};
@@ -1692,7 +1800,7 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/plex/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/sources/group_connections/oauth/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -1704,19 +1812,15 @@ export class SourcesApi extends runtime.BaseAPI {
     /**
      * 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);
+    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 sourcesGroupConnectionsSamlDestroyRaw(requestParameters: SourcesGroupConnectionsSamlDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsSamlDestroy.');
-        }
-
+    async sourcesGroupConnectionsPlexCreateRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupPlexSourceConnection>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -1730,41 +1834,79 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/saml/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'DELETE',
+            path: `/sources/group_connections/plex/`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => GroupPlexSourceConnectionFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsSamlDestroy(requestParameters: SourcesGroupConnectionsSamlDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.sourcesGroupConnectionsSamlDestroyRaw(requestParameters, initOverrides);
+    async sourcesGroupConnectionsPlexCreate(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupPlexSourceConnection> {
+        const response = await this.sourcesGroupConnectionsPlexCreateRaw(initOverrides);
+        return await response.value();
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsSamlListRaw(requestParameters: SourcesGroupConnectionsSamlListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGroupSAMLSourceConnectionList>> {
-        const queryParameters: any = {};
-
-        if (requestParameters.group !== undefined) {
-            queryParameters['group'] = requestParameters.group;
+    async sourcesGroupConnectionsPlexDestroyRaw(requestParameters: SourcesGroupConnectionsPlexDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsPlexDestroy.');
         }
 
-        if (requestParameters.ordering !== undefined) {
-            queryParameters['ordering'] = requestParameters.ordering;
-        }
+        const queryParameters: any = {};
 
-        if (requestParameters.page !== undefined) {
-            queryParameters['page'] = requestParameters.page;
-        }
+        const headerParameters: runtime.HTTPHeaders = {};
 
-        if (requestParameters.pageSize !== undefined) {
+        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 !== undefined) {
+            queryParameters['group'] = requestParameters.group;
+        }
+
+        if (requestParameters.ordering !== undefined) {
+            queryParameters['ordering'] = requestParameters.ordering;
+        }
+
+        if (requestParameters.page !== undefined) {
+            queryParameters['page'] = requestParameters.page;
+        }
+
+        if (requestParameters.pageSize !== undefined) {
             queryParameters['page_size'] = requestParameters.pageSize;
         }
 
@@ -1787,29 +1929,29 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/saml/`,
+            path: `/sources/group_connections/plex/`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedGroupSAMLSourceConnectionListFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedGroupPlexSourceConnectionListFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsSamlList(requestParameters: SourcesGroupConnectionsSamlListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedGroupSAMLSourceConnectionList> {
-        const response = await this.sourcesGroupConnectionsSamlListRaw(requestParameters, initOverrides);
+    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 sourcesGroupConnectionsSamlPartialUpdateRaw(requestParameters: SourcesGroupConnectionsSamlPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupSAMLSourceConnection>> {
+    async sourcesGroupConnectionsPlexPartialUpdateRaw(requestParameters: SourcesGroupConnectionsPlexPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupPlexSourceConnection>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsSamlPartialUpdate.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsPlexPartialUpdate.');
         }
 
         const queryParameters: any = {};
@@ -1825,29 +1967,143 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/saml/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/sources/group_connections/plex/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GroupSAMLSourceConnectionFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GroupPlexSourceConnectionFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsSamlPartialUpdate(requestParameters: SourcesGroupConnectionsSamlPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupSAMLSourceConnection> {
-        const response = await this.sourcesGroupConnectionsSamlPartialUpdateRaw(requestParameters, initOverrides);
+    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 sourcesGroupConnectionsSamlRetrieveRaw(requestParameters: SourcesGroupConnectionsSamlRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupSAMLSourceConnection>> {
+    async sourcesGroupConnectionsPlexRetrieveRaw(requestParameters: SourcesGroupConnectionsPlexRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupPlexSourceConnection>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsSamlRetrieve.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.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 || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsPlexUpdate.');
+        }
+
+        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: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+        }, 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 || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.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 sourcesGroupConnectionsSamlDestroyRaw(requestParameters: SourcesGroupConnectionsSamlDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsSamlDestroy.');
         }
 
         const queryParameters: any = {};
@@ -1864,28 +2120,85 @@ export class SourcesApi extends runtime.BaseAPI {
         }
         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 !== undefined) {
+            queryParameters['group'] = requestParameters.group;
+        }
+
+        if (requestParameters.ordering !== undefined) {
+            queryParameters['ordering'] = requestParameters.ordering;
+        }
+
+        if (requestParameters.page !== undefined) {
+            queryParameters['page'] = requestParameters.page;
+        }
+
+        if (requestParameters.pageSize !== undefined) {
+            queryParameters['page_size'] = requestParameters.pageSize;
+        }
+
+        if (requestParameters.search !== undefined) {
+            queryParameters['search'] = requestParameters.search;
+        }
+
+        if (requestParameters.sourceSlug !== undefined) {
+            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) => GroupSAMLSourceConnectionFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedGroupSAMLSourceConnectionListFromJSON(jsonValue));
     }
 
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsSamlRetrieve(requestParameters: SourcesGroupConnectionsSamlRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupSAMLSourceConnection> {
-        const response = await this.sourcesGroupConnectionsSamlRetrieveRaw(requestParameters, initOverrides);
+    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 sourcesGroupConnectionsSamlUpdateRaw(requestParameters: SourcesGroupConnectionsSamlUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupSAMLSourceConnection>> {
+    async sourcesGroupConnectionsSamlPartialUpdateRaw(requestParameters: SourcesGroupConnectionsSamlPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GroupSAMLSourceConnection>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsSamlUpdate.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsSamlPartialUpdate.');
         }
 
         const queryParameters: any = {};
@@ -1902,7 +2215,7 @@ export class SourcesApi extends runtime.BaseAPI {
         }
         const response = await this.request({
             path: `/sources/group_connections/saml/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'PUT',
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
@@ -1913,17 +2226,457 @@ export class SourcesApi extends runtime.BaseAPI {
     /**
      * Group-source connection Viewset
      */
-    async sourcesGroupConnectionsSamlUpdate(requestParameters: SourcesGroupConnectionsSamlUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GroupSAMLSourceConnection> {
-        const response = await this.sourcesGroupConnectionsSamlUpdateRaw(requestParameters, initOverrides);
+    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 || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.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 || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsSamlUpdate.');
+        }
+
+        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: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+        }, 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 || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.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 || requestParameters.kerberosSourceRequest === undefined) {
+            throw new runtime.RequiredError('kerberosSourceRequest','Required parameter requestParameters.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 || requestParameters.slug === undefined) {
+            throw new runtime.RequiredError('slug','Required parameter requestParameters.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 !== undefined) {
+            queryParameters['enabled'] = requestParameters.enabled;
+        }
+
+        if (requestParameters.name !== undefined) {
+            queryParameters['name'] = requestParameters.name;
+        }
+
+        if (requestParameters.ordering !== undefined) {
+            queryParameters['ordering'] = requestParameters.ordering;
+        }
+
+        if (requestParameters.page !== undefined) {
+            queryParameters['page'] = requestParameters.page;
+        }
+
+        if (requestParameters.pageSize !== undefined) {
+            queryParameters['page_size'] = requestParameters.pageSize;
+        }
+
+        if (requestParameters.passwordLoginUpdateInternalPassword !== undefined) {
+            queryParameters['password_login_update_internal_password'] = requestParameters.passwordLoginUpdateInternalPassword;
+        }
+
+        if (requestParameters.realm !== undefined) {
+            queryParameters['realm'] = requestParameters.realm;
+        }
+
+        if (requestParameters.search !== undefined) {
+            queryParameters['search'] = requestParameters.search;
+        }
+
+        if (requestParameters.slug !== undefined) {
+            queryParameters['slug'] = requestParameters.slug;
+        }
+
+        if (requestParameters.spnegoServerName !== undefined) {
+            queryParameters['spnego_server_name'] = requestParameters.spnegoServerName;
+        }
+
+        if (requestParameters.syncPrincipal !== undefined) {
+            queryParameters['sync_principal'] = requestParameters.syncPrincipal;
+        }
+
+        if (requestParameters.syncUsers !== undefined) {
+            queryParameters['sync_users'] = requestParameters.syncUsers;
+        }
+
+        if (requestParameters.syncUsersPassword !== undefined) {
+            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 || requestParameters.slug === undefined) {
+            throw new runtime.RequiredError('slug','Required parameter requestParameters.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 || requestParameters.slug === undefined) {
+            throw new runtime.RequiredError('slug','Required parameter requestParameters.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 || requestParameters.slug === undefined) {
+            throw new runtime.RequiredError('slug','Required parameter requestParameters.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 || requestParameters.slug === undefined) {
+            throw new runtime.RequiredError('slug','Required parameter requestParameters.slug was null or undefined when calling sourcesKerberosUpdate.');
+        }
+
+        if (requestParameters.kerberosSourceRequest === null || requestParameters.kerberosSourceRequest === undefined) {
+            throw new runtime.RequiredError('kerberosSourceRequest','Required parameter requestParameters.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 sourcesGroupConnectionsSamlUsedByListRaw(requestParameters: SourcesGroupConnectionsSamlUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesGroupConnectionsSamlUsedByList.');
+    async sourcesKerberosUsedByListRaw(requestParameters: SourcesKerberosUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
+        if (requestParameters.slug === null || requestParameters.slug === undefined) {
+            throw new runtime.RequiredError('slug','Required parameter requestParameters.slug was null or undefined when calling sourcesKerberosUsedByList.');
         }
 
         const queryParameters: any = {};
@@ -1939,7 +2692,7 @@ export class SourcesApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/sources/group_connections/saml/{id}/used_by/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/sources/kerberos/{slug}/used_by/`.replace(`{${"slug"}}`, encodeURIComponent(String(requestParameters.slug))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -1951,8 +2704,8 @@ export class SourcesApi extends runtime.BaseAPI {
     /**
      * 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);
+    async sourcesKerberosUsedByList(requestParameters: SourcesKerberosUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UsedBy>> {
+        const response = await this.sourcesKerberosUsedByListRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -4782,6 +5535,300 @@ export class SourcesApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Source Viewset
+     */
+    async sourcesUserConnectionsKerberosCreateRaw(requestParameters: SourcesUserConnectionsKerberosCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserKerberosSourceConnection>> {
+        if (requestParameters.userKerberosSourceConnectionRequest === null || requestParameters.userKerberosSourceConnectionRequest === undefined) {
+            throw new runtime.RequiredError('userKerberosSourceConnectionRequest','Required parameter requestParameters.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));
+    }
+
+    /**
+     * Source Viewset
+     */
+    async sourcesUserConnectionsKerberosCreate(requestParameters: SourcesUserConnectionsKerberosCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserKerberosSourceConnection> {
+        const response = await this.sourcesUserConnectionsKerberosCreateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Source Viewset
+     */
+    async sourcesUserConnectionsKerberosDestroyRaw(requestParameters: SourcesUserConnectionsKerberosDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling 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);
+    }
+
+    /**
+     * Source Viewset
+     */
+    async sourcesUserConnectionsKerberosDestroy(requestParameters: SourcesUserConnectionsKerberosDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.sourcesUserConnectionsKerberosDestroyRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Source Viewset
+     */
+    async sourcesUserConnectionsKerberosListRaw(requestParameters: SourcesUserConnectionsKerberosListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedUserKerberosSourceConnectionList>> {
+        const queryParameters: any = {};
+
+        if (requestParameters.ordering !== undefined) {
+            queryParameters['ordering'] = requestParameters.ordering;
+        }
+
+        if (requestParameters.page !== undefined) {
+            queryParameters['page'] = requestParameters.page;
+        }
+
+        if (requestParameters.pageSize !== undefined) {
+            queryParameters['page_size'] = requestParameters.pageSize;
+        }
+
+        if (requestParameters.search !== undefined) {
+            queryParameters['search'] = requestParameters.search;
+        }
+
+        if (requestParameters.sourceSlug !== undefined) {
+            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/user_connections/kerberos/`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedUserKerberosSourceConnectionListFromJSON(jsonValue));
+    }
+
+    /**
+     * Source Viewset
+     */
+    async sourcesUserConnectionsKerberosList(requestParameters: SourcesUserConnectionsKerberosListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedUserKerberosSourceConnectionList> {
+        const response = await this.sourcesUserConnectionsKerberosListRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Source Viewset
+     */
+    async sourcesUserConnectionsKerberosPartialUpdateRaw(requestParameters: SourcesUserConnectionsKerberosPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserKerberosSourceConnection>> {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.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));
+    }
+
+    /**
+     * Source Viewset
+     */
+    async sourcesUserConnectionsKerberosPartialUpdate(requestParameters: SourcesUserConnectionsKerberosPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserKerberosSourceConnection> {
+        const response = await this.sourcesUserConnectionsKerberosPartialUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Source Viewset
+     */
+    async sourcesUserConnectionsKerberosRetrieveRaw(requestParameters: SourcesUserConnectionsKerberosRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserKerberosSourceConnection>> {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.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));
+    }
+
+    /**
+     * Source Viewset
+     */
+    async sourcesUserConnectionsKerberosRetrieve(requestParameters: SourcesUserConnectionsKerberosRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserKerberosSourceConnection> {
+        const response = await this.sourcesUserConnectionsKerberosRetrieveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Source Viewset
+     */
+    async sourcesUserConnectionsKerberosUpdateRaw(requestParameters: SourcesUserConnectionsKerberosUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserKerberosSourceConnection>> {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling sourcesUserConnectionsKerberosUpdate.');
+        }
+
+        if (requestParameters.userKerberosSourceConnectionRequest === null || requestParameters.userKerberosSourceConnectionRequest === undefined) {
+            throw new runtime.RequiredError('userKerberosSourceConnectionRequest','Required parameter requestParameters.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));
+    }
+
+    /**
+     * Source 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 || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.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();
+    }
+
     /**
      * Source Viewset
      */