@goauthentik/api 2023.10.7-1707429127 → 2023.10.7-1707933453

package/src/apis/RacApi.ts

@@ -15,23 +15,35 @@
 
 import * as runtime from '../runtime';
 import type {
+  ConnectionToken,
+  ConnectionTokenRequest,
   Endpoint,
   EndpointRequest,
   GenericError,
+  PaginatedConnectionTokenList,
   PaginatedEndpointList,
+  PatchedConnectionTokenRequest,
   PatchedEndpointRequest,
   UsedBy,
   ValidationError,
 } from '../models';
 import {
+    ConnectionTokenFromJSON,
+    ConnectionTokenToJSON,
+    ConnectionTokenRequestFromJSON,
+    ConnectionTokenRequestToJSON,
     EndpointFromJSON,
     EndpointToJSON,
     EndpointRequestFromJSON,
     EndpointRequestToJSON,
     GenericErrorFromJSON,
     GenericErrorToJSON,
+    PaginatedConnectionTokenListFromJSON,
+    PaginatedConnectionTokenListToJSON,
     PaginatedEndpointListFromJSON,
     PaginatedEndpointListToJSON,
+    PatchedConnectionTokenRequestFromJSON,
+    PatchedConnectionTokenRequestToJSON,
     PatchedEndpointRequestFromJSON,
     PatchedEndpointRequestToJSON,
     UsedByFromJSON,
@@ -40,6 +52,38 @@ import {
     ValidationErrorToJSON,
 } from '../models';
 
+export interface RacConnectionTokensDestroyRequest {
+    connectionTokenUuid: string;
+}
+
+export interface RacConnectionTokensListRequest {
+    endpoint?: string;
+    ordering?: string;
+    page?: number;
+    pageSize?: number;
+    provider?: number;
+    search?: string;
+    sessionUser?: number;
+}
+
+export interface RacConnectionTokensPartialUpdateRequest {
+    connectionTokenUuid: string;
+    patchedConnectionTokenRequest?: PatchedConnectionTokenRequest;
+}
+
+export interface RacConnectionTokensRetrieveRequest {
+    connectionTokenUuid: string;
+}
+
+export interface RacConnectionTokensUpdateRequest {
+    connectionTokenUuid: string;
+    connectionTokenRequest: ConnectionTokenRequest;
+}
+
+export interface RacConnectionTokensUsedByListRequest {
+    connectionTokenUuid: string;
+}
+
 export interface RacEndpointsCreateRequest {
     endpointRequest: EndpointRequest;
 }
@@ -81,6 +125,243 @@ export interface RacEndpointsUsedByListRequest {
  */
 export class RacApi extends runtime.BaseAPI {
 
+    /**
+     * ConnectionToken Viewset
+     */
+    async racConnectionTokensDestroyRaw(requestParameters: RacConnectionTokensDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.connectionTokenUuid === null || requestParameters.connectionTokenUuid === undefined) {
+            throw new runtime.RequiredError('connectionTokenUuid','Required parameter requestParameters.connectionTokenUuid was null or undefined when calling racConnectionTokensDestroy.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // authentik authentication
+        }
+
+        const response = await this.request({
+            path: `/rac/connection_tokens/{connection_token_uuid}/`.replace(`{${"connection_token_uuid"}}`, encodeURIComponent(String(requestParameters.connectionTokenUuid))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * ConnectionToken Viewset
+     */
+    async racConnectionTokensDestroy(requestParameters: RacConnectionTokensDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.racConnectionTokensDestroyRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * ConnectionToken Viewset
+     */
+    async racConnectionTokensListRaw(requestParameters: RacConnectionTokensListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedConnectionTokenList>> {
+        const queryParameters: any = {};
+
+        if (requestParameters.endpoint !== undefined) {
+            queryParameters['endpoint'] = requestParameters.endpoint;
+        }
+
+        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.provider !== undefined) {
+            queryParameters['provider'] = requestParameters.provider;
+        }
+
+        if (requestParameters.search !== undefined) {
+            queryParameters['search'] = requestParameters.search;
+        }
+
+        if (requestParameters.sessionUser !== undefined) {
+            queryParameters['session__user'] = requestParameters.sessionUser;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // authentik authentication
+        }
+
+        const response = await this.request({
+            path: `/rac/connection_tokens/`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedConnectionTokenListFromJSON(jsonValue));
+    }
+
+    /**
+     * ConnectionToken Viewset
+     */
+    async racConnectionTokensList(requestParameters: RacConnectionTokensListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedConnectionTokenList> {
+        const response = await this.racConnectionTokensListRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * ConnectionToken Viewset
+     */
+    async racConnectionTokensPartialUpdateRaw(requestParameters: RacConnectionTokensPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ConnectionToken>> {
+        if (requestParameters.connectionTokenUuid === null || requestParameters.connectionTokenUuid === undefined) {
+            throw new runtime.RequiredError('connectionTokenUuid','Required parameter requestParameters.connectionTokenUuid was null or undefined when calling racConnectionTokensPartialUpdate.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // authentik authentication
+        }
+
+        const response = await this.request({
+            path: `/rac/connection_tokens/{connection_token_uuid}/`.replace(`{${"connection_token_uuid"}}`, encodeURIComponent(String(requestParameters.connectionTokenUuid))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PatchedConnectionTokenRequestToJSON(requestParameters.patchedConnectionTokenRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ConnectionTokenFromJSON(jsonValue));
+    }
+
+    /**
+     * ConnectionToken Viewset
+     */
+    async racConnectionTokensPartialUpdate(requestParameters: RacConnectionTokensPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ConnectionToken> {
+        const response = await this.racConnectionTokensPartialUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * ConnectionToken Viewset
+     */
+    async racConnectionTokensRetrieveRaw(requestParameters: RacConnectionTokensRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ConnectionToken>> {
+        if (requestParameters.connectionTokenUuid === null || requestParameters.connectionTokenUuid === undefined) {
+            throw new runtime.RequiredError('connectionTokenUuid','Required parameter requestParameters.connectionTokenUuid was null or undefined when calling racConnectionTokensRetrieve.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // authentik authentication
+        }
+
+        const response = await this.request({
+            path: `/rac/connection_tokens/{connection_token_uuid}/`.replace(`{${"connection_token_uuid"}}`, encodeURIComponent(String(requestParameters.connectionTokenUuid))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ConnectionTokenFromJSON(jsonValue));
+    }
+
+    /**
+     * ConnectionToken Viewset
+     */
+    async racConnectionTokensRetrieve(requestParameters: RacConnectionTokensRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ConnectionToken> {
+        const response = await this.racConnectionTokensRetrieveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * ConnectionToken Viewset
+     */
+    async racConnectionTokensUpdateRaw(requestParameters: RacConnectionTokensUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ConnectionToken>> {
+        if (requestParameters.connectionTokenUuid === null || requestParameters.connectionTokenUuid === undefined) {
+            throw new runtime.RequiredError('connectionTokenUuid','Required parameter requestParameters.connectionTokenUuid was null or undefined when calling racConnectionTokensUpdate.');
+        }
+
+        if (requestParameters.connectionTokenRequest === null || requestParameters.connectionTokenRequest === undefined) {
+            throw new runtime.RequiredError('connectionTokenRequest','Required parameter requestParameters.connectionTokenRequest was null or undefined when calling racConnectionTokensUpdate.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // authentik authentication
+        }
+
+        const response = await this.request({
+            path: `/rac/connection_tokens/{connection_token_uuid}/`.replace(`{${"connection_token_uuid"}}`, encodeURIComponent(String(requestParameters.connectionTokenUuid))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ConnectionTokenRequestToJSON(requestParameters.connectionTokenRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ConnectionTokenFromJSON(jsonValue));
+    }
+
+    /**
+     * ConnectionToken Viewset
+     */
+    async racConnectionTokensUpdate(requestParameters: RacConnectionTokensUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ConnectionToken> {
+        const response = await this.racConnectionTokensUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Get a list of all objects that use this object
+     */
+    async racConnectionTokensUsedByListRaw(requestParameters: RacConnectionTokensUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UsedBy>>> {
+        if (requestParameters.connectionTokenUuid === null || requestParameters.connectionTokenUuid === undefined) {
+            throw new runtime.RequiredError('connectionTokenUuid','Required parameter requestParameters.connectionTokenUuid was null or undefined when calling racConnectionTokensUsedByList.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // authentik authentication
+        }
+
+        const response = await this.request({
+            path: `/rac/connection_tokens/{connection_token_uuid}/used_by/`.replace(`{${"connection_token_uuid"}}`, encodeURIComponent(String(requestParameters.connectionTokenUuid))),
+            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 racConnectionTokensUsedByList(requestParameters: RacConnectionTokensUsedByListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UsedBy>> {
+        const response = await this.racConnectionTokensUsedByListRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Endpoint Viewset
      */

package/src/models/ConnectionToken.ts

@@ -0,0 +1,125 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * authentik
+ * Making authentication simple.
+ *
+ * The version of the OpenAPI document: 2023.10.7
+ * Contact: hello@goauthentik.io
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import type { Endpoint } from './Endpoint';
+import {
+    EndpointFromJSON,
+    EndpointFromJSONTyped,
+    EndpointToJSON,
+} from './Endpoint';
+import type { GroupMember } from './GroupMember';
+import {
+    GroupMemberFromJSON,
+    GroupMemberFromJSONTyped,
+    GroupMemberToJSON,
+} from './GroupMember';
+import type { RACProvider } from './RACProvider';
+import {
+    RACProviderFromJSON,
+    RACProviderFromJSONTyped,
+    RACProviderToJSON,
+} from './RACProvider';
+
+/**
+ * ConnectionToken Serializer
+ * @export
+ * @interface ConnectionToken
+ */
+export interface ConnectionToken {
+    /**
+     * 
+     * @type {string}
+     * @memberof ConnectionToken
+     */
+    readonly pk: string;
+    /**
+     * 
+     * @type {number}
+     * @memberof ConnectionToken
+     */
+    provider: number;
+    /**
+     * 
+     * @type {RACProvider}
+     * @memberof ConnectionToken
+     */
+    readonly providerObj: RACProvider;
+    /**
+     * 
+     * @type {string}
+     * @memberof ConnectionToken
+     */
+    readonly endpoint: string;
+    /**
+     * 
+     * @type {Endpoint}
+     * @memberof ConnectionToken
+     */
+    readonly endpointObj: Endpoint;
+    /**
+     * 
+     * @type {GroupMember}
+     * @memberof ConnectionToken
+     */
+    readonly user: GroupMember;
+}
+
+/**
+ * Check if a given object implements the ConnectionToken interface.
+ */
+export function instanceOfConnectionToken(value: object): boolean {
+    let isInstance = true;
+    isInstance = isInstance && "pk" in value;
+    isInstance = isInstance && "provider" in value;
+    isInstance = isInstance && "providerObj" in value;
+    isInstance = isInstance && "endpoint" in value;
+    isInstance = isInstance && "endpointObj" in value;
+    isInstance = isInstance && "user" in value;
+
+    return isInstance;
+}
+
+export function ConnectionTokenFromJSON(json: any): ConnectionToken {
+    return ConnectionTokenFromJSONTyped(json, false);
+}
+
+export function ConnectionTokenFromJSONTyped(json: any, ignoreDiscriminator: boolean): ConnectionToken {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'pk': json['pk'],
+        'provider': json['provider'],
+        'providerObj': RACProviderFromJSON(json['provider_obj']),
+        'endpoint': json['endpoint'],
+        'endpointObj': EndpointFromJSON(json['endpoint_obj']),
+        'user': GroupMemberFromJSON(json['user']),
+    };
+}
+
+export function ConnectionTokenToJSON(value?: ConnectionToken | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'provider': value.provider,
+    };
+}
+

package/src/models/ConnectionTokenRequest.ts

@@ -0,0 +1,66 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * authentik
+ * Making authentication simple.
+ *
+ * The version of the OpenAPI document: 2023.10.7
+ * Contact: hello@goauthentik.io
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * ConnectionToken Serializer
+ * @export
+ * @interface ConnectionTokenRequest
+ */
+export interface ConnectionTokenRequest {
+    /**
+     * 
+     * @type {number}
+     * @memberof ConnectionTokenRequest
+     */
+    provider: number;
+}
+
+/**
+ * Check if a given object implements the ConnectionTokenRequest interface.
+ */
+export function instanceOfConnectionTokenRequest(value: object): boolean {
+    let isInstance = true;
+    isInstance = isInstance && "provider" in value;
+
+    return isInstance;
+}
+
+export function ConnectionTokenRequestFromJSON(json: any): ConnectionTokenRequest {
+    return ConnectionTokenRequestFromJSONTyped(json, false);
+}
+
+export function ConnectionTokenRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): ConnectionTokenRequest {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'provider': json['provider'],
+    };
+}
+
+export function ConnectionTokenRequestToJSON(value?: ConnectionTokenRequest | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'provider': value.provider,
+    };
+}
+

package/src/models/PaginatedConnectionTokenList.ts

@@ -0,0 +1,88 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * authentik
+ * Making authentication simple.
+ *
+ * The version of the OpenAPI document: 2023.10.7
+ * Contact: hello@goauthentik.io
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import type { ConnectionToken } from './ConnectionToken';
+import {
+    ConnectionTokenFromJSON,
+    ConnectionTokenFromJSONTyped,
+    ConnectionTokenToJSON,
+} from './ConnectionToken';
+import type { Pagination } from './Pagination';
+import {
+    PaginationFromJSON,
+    PaginationFromJSONTyped,
+    PaginationToJSON,
+} from './Pagination';
+
+/**
+ * 
+ * @export
+ * @interface PaginatedConnectionTokenList
+ */
+export interface PaginatedConnectionTokenList {
+    /**
+     * 
+     * @type {Pagination}
+     * @memberof PaginatedConnectionTokenList
+     */
+    pagination: Pagination;
+    /**
+     * 
+     * @type {Array<ConnectionToken>}
+     * @memberof PaginatedConnectionTokenList
+     */
+    results: Array<ConnectionToken>;
+}
+
+/**
+ * Check if a given object implements the PaginatedConnectionTokenList interface.
+ */
+export function instanceOfPaginatedConnectionTokenList(value: object): boolean {
+    let isInstance = true;
+    isInstance = isInstance && "pagination" in value;
+    isInstance = isInstance && "results" in value;
+
+    return isInstance;
+}
+
+export function PaginatedConnectionTokenListFromJSON(json: any): PaginatedConnectionTokenList {
+    return PaginatedConnectionTokenListFromJSONTyped(json, false);
+}
+
+export function PaginatedConnectionTokenListFromJSONTyped(json: any, ignoreDiscriminator: boolean): PaginatedConnectionTokenList {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'pagination': PaginationFromJSON(json['pagination']),
+        'results': ((json['results'] as Array<any>).map(ConnectionTokenFromJSON)),
+    };
+}
+
+export function PaginatedConnectionTokenListToJSON(value?: PaginatedConnectionTokenList | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'pagination': PaginationToJSON(value.pagination),
+        'results': ((value.results as Array<any>).map(ConnectionTokenToJSON)),
+    };
+}
+

package/src/models/PatchedConnectionTokenRequest.ts

@@ -0,0 +1,65 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * authentik
+ * Making authentication simple.
+ *
+ * The version of the OpenAPI document: 2023.10.7
+ * Contact: hello@goauthentik.io
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * ConnectionToken Serializer
+ * @export
+ * @interface PatchedConnectionTokenRequest
+ */
+export interface PatchedConnectionTokenRequest {
+    /**
+     * 
+     * @type {number}
+     * @memberof PatchedConnectionTokenRequest
+     */
+    provider?: number;
+}
+
+/**
+ * Check if a given object implements the PatchedConnectionTokenRequest interface.
+ */
+export function instanceOfPatchedConnectionTokenRequest(value: object): boolean {
+    let isInstance = true;
+
+    return isInstance;
+}
+
+export function PatchedConnectionTokenRequestFromJSON(json: any): PatchedConnectionTokenRequest {
+    return PatchedConnectionTokenRequestFromJSONTyped(json, false);
+}
+
+export function PatchedConnectionTokenRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): PatchedConnectionTokenRequest {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'provider': !exists(json, 'provider') ? undefined : json['provider'],
+    };
+}
+
+export function PatchedConnectionTokenRequestToJSON(value?: PatchedConnectionTokenRequest | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'provider': value.provider,
+    };
+}
+

package/src/models/PatchedRACProviderRequest.ts

@@ -55,6 +55,12 @@ export interface PatchedRACProviderRequest {
      * @memberof PatchedRACProviderRequest
      */
     connectionExpiry?: string;
+    /**
+     * When set to true, connection tokens will be deleted upon disconnect.
+     * @type {boolean}
+     * @memberof PatchedRACProviderRequest
+     */
+    deleteTokenOnDisconnect?: boolean;
 }
 
 /**
@@ -82,6 +88,7 @@ export function PatchedRACProviderRequestFromJSONTyped(json: any, ignoreDiscrimi
         'propertyMappings': !exists(json, 'property_mappings') ? undefined : json['property_mappings'],
         'settings': !exists(json, 'settings') ? undefined : json['settings'],
         'connectionExpiry': !exists(json, 'connection_expiry') ? undefined : json['connection_expiry'],
+        'deleteTokenOnDisconnect': !exists(json, 'delete_token_on_disconnect') ? undefined : json['delete_token_on_disconnect'],
     };
 }
 
@@ -100,6 +107,7 @@ export function PatchedRACProviderRequestToJSON(value?: PatchedRACProviderReques
         'property_mappings': value.propertyMappings,
         'settings': value.settings,
         'connection_expiry': value.connectionExpiry,
+        'delete_token_on_disconnect': value.deleteTokenOnDisconnect,
     };
 }