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

import * as runtime from '../runtime';
import {
    type GenericError,
    GenericErrorFromJSON,
    GenericErrorToJSON,
} from '../models/GenericError';
import {
    type LifecycleIteration,
    LifecycleIterationFromJSON,
    LifecycleIterationToJSON,
} from '../models/LifecycleIteration';
import {
    type LifecycleIterationRequest,
    LifecycleIterationRequestFromJSON,
    LifecycleIterationRequestToJSON,
} from '../models/LifecycleIterationRequest';
import {
    type LifecycleRule,
    LifecycleRuleFromJSON,
    LifecycleRuleToJSON,
} from '../models/LifecycleRule';
import {
    type LifecycleRuleRequest,
    LifecycleRuleRequestFromJSON,
    LifecycleRuleRequestToJSON,
} from '../models/LifecycleRuleRequest';
import {
    type OffboardingActionEnum,
    OffboardingActionEnumFromJSON,
    OffboardingActionEnumToJSON,
} from '../models/OffboardingActionEnum';
import {
    type OffboardingStatusEnum,
    OffboardingStatusEnumFromJSON,
    OffboardingStatusEnumToJSON,
} from '../models/OffboardingStatusEnum';
import {
    type PaginatedLifecycleIterationList,
    PaginatedLifecycleIterationListFromJSON,
    PaginatedLifecycleIterationListToJSON,
} from '../models/PaginatedLifecycleIterationList';
import {
    type PaginatedLifecycleRuleList,
    PaginatedLifecycleRuleListFromJSON,
    PaginatedLifecycleRuleListToJSON,
} from '../models/PaginatedLifecycleRuleList';
import {
    type PaginatedUserOffboardingList,
    PaginatedUserOffboardingListFromJSON,
    PaginatedUserOffboardingListToJSON,
} from '../models/PaginatedUserOffboardingList';
import {
    type PatchedLifecycleRuleRequest,
    PatchedLifecycleRuleRequestFromJSON,
    PatchedLifecycleRuleRequestToJSON,
} from '../models/PatchedLifecycleRuleRequest';
import {
    type Review,
    ReviewFromJSON,
    ReviewToJSON,
} from '../models/Review';
import {
    type ReviewRequest,
    ReviewRequestFromJSON,
    ReviewRequestToJSON,
} from '../models/ReviewRequest';
import {
    type UserOffboarding,
    UserOffboardingFromJSON,
    UserOffboardingToJSON,
} from '../models/UserOffboarding';
import {
    type UserOffboardingRequest,
    UserOffboardingRequestFromJSON,
    UserOffboardingRequestToJSON,
} from '../models/UserOffboardingRequest';
import {
    type ValidationError,
    ValidationErrorFromJSON,
    ValidationErrorToJSON,
} from '../models/ValidationError';

export interface LifecycleIterationsCreateRequest {
    lifecycleIterationRequest: LifecycleIterationRequest;
}

export interface LifecycleIterationsListLatestRequest {
    contentType: string;
    objectId: string;
    ordering?: string;
    search?: string;
    userIsReviewer?: boolean;
}

export interface LifecycleIterationsListOpenRequest {
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    userIsReviewer?: boolean;
}

export interface LifecycleReviewsCreateRequest {
    reviewRequest: ReviewRequest;
}

export interface LifecycleRulesCreateRequest {
    lifecycleRuleRequest: LifecycleRuleRequest;
}

export interface LifecycleRulesDestroyRequest {
    id: string;
}

export interface LifecycleRulesListRequest {
    contentTypeModel?: string;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
}

export interface LifecycleRulesPartialUpdateRequest {
    id: string;
    patchedLifecycleRuleRequest?: PatchedLifecycleRuleRequest;
}

export interface LifecycleRulesRetrieveRequest {
    id: string;
}

export interface LifecycleRulesUpdateRequest {
    id: string;
    lifecycleRuleRequest: LifecycleRuleRequest;
}

export interface LifecycleUserOffboardingCreateRequest {
    userOffboardingRequest: UserOffboardingRequest;
}

export interface LifecycleUserOffboardingDestroyRequest {
    id: string;
}

export interface LifecycleUserOffboardingListRequest {
    action?: OffboardingActionEnum;
    ordering?: string;
    page?: number;
    pageSize?: number;
    search?: string;
    status?: OffboardingStatusEnum;
    userUuid?: string;
}

export interface LifecycleUserOffboardingRetrieveRequest {
    id: string;
}

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

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/iterations/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: LifecycleIterationRequestToJSON(requestParameters['lifecycleIterationRequest']),
        };
    }

    /**
     * Mixin to validate that a valid enterprise license exists before allowing to save the object
     */
    async lifecycleIterationsCreateRaw(requestParameters: LifecycleIterationsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LifecycleIteration>> {
        const requestOptions = await this.lifecycleIterationsCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to validate that a valid enterprise license exists before allowing to save the object
     */
    async lifecycleIterationsCreate(requestParameters: LifecycleIterationsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LifecycleIteration> {
        const response = await this.lifecycleIterationsCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        const queryParameters: any = {};

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/iterations/latest/{content_type}/{object_id}/`;
        urlPath = urlPath.replace('{content_type}', encodeURIComponent(String(requestParameters['contentType'])));
        urlPath = urlPath.replace('{object_id}', encodeURIComponent(String(requestParameters['objectId'])));

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

    /**
     * Mixin to validate that a valid enterprise license exists before allowing to save the object
     */
    async lifecycleIterationsListLatestRaw(requestParameters: LifecycleIterationsListLatestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<LifecycleIteration>>> {
        const requestOptions = await this.lifecycleIterationsListLatestRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to validate that a valid enterprise license exists before allowing to save the object
     */
    async lifecycleIterationsListLatest(requestParameters: LifecycleIterationsListLatestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<LifecycleIteration>> {
        const response = await this.lifecycleIterationsListLatestRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Creates request options for lifecycleIterationsListOpen without sending the request
     */
    async lifecycleIterationsListOpenRequestOpts(requestParameters: LifecycleIterationsListOpenRequest): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/iterations/open/`;

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

    /**
     * Mixin to validate that a valid enterprise license exists before allowing to save the object
     */
    async lifecycleIterationsListOpenRaw(requestParameters: LifecycleIterationsListOpenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedLifecycleIterationList>> {
        const requestOptions = await this.lifecycleIterationsListOpenRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to validate that a valid enterprise license exists before allowing to save the object
     */
    async lifecycleIterationsListOpen(requestParameters: LifecycleIterationsListOpenRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedLifecycleIterationList> {
        const response = await this.lifecycleIterationsListOpenRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/reviews/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ReviewRequestToJSON(requestParameters['reviewRequest']),
        };
    }

    /**
     * Mixin to validate that a valid enterprise license exists before allowing to save the object
     */
    async lifecycleReviewsCreateRaw(requestParameters: LifecycleReviewsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Review>> {
        const requestOptions = await this.lifecycleReviewsCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     * Mixin to validate that a valid enterprise license exists before allowing to save the object
     */
    async lifecycleReviewsCreate(requestParameters: LifecycleReviewsCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Review> {
        const response = await this.lifecycleReviewsCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/rules/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: LifecycleRuleRequestToJSON(requestParameters['lifecycleRuleRequest']),
        };
    }

    /**
     */
    async lifecycleRulesCreateRaw(requestParameters: LifecycleRulesCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LifecycleRule>> {
        const requestOptions = await this.lifecycleRulesCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     */
    async lifecycleRulesCreate(requestParameters: LifecycleRulesCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LifecycleRule> {
        const response = await this.lifecycleRulesCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/rules/{id}/`;
        urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));

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

    /**
     */
    async lifecycleRulesDestroyRaw(requestParameters: LifecycleRulesDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const requestOptions = await this.lifecycleRulesDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     */
    async lifecycleRulesDestroy(requestParameters: LifecycleRulesDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.lifecycleRulesDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for lifecycleRulesList without sending the request
     */
    async lifecycleRulesListRequestOpts(requestParameters: LifecycleRulesListRequest): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/rules/`;

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

    /**
     */
    async lifecycleRulesListRaw(requestParameters: LifecycleRulesListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedLifecycleRuleList>> {
        const requestOptions = await this.lifecycleRulesListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     */
    async lifecycleRulesList(requestParameters: LifecycleRulesListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedLifecycleRuleList> {
        const response = await this.lifecycleRulesListRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/rules/{id}/`;
        urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));

        return {
            path: urlPath,
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PatchedLifecycleRuleRequestToJSON(requestParameters['patchedLifecycleRuleRequest']),
        };
    }

    /**
     */
    async lifecycleRulesPartialUpdateRaw(requestParameters: LifecycleRulesPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LifecycleRule>> {
        const requestOptions = await this.lifecycleRulesPartialUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     */
    async lifecycleRulesPartialUpdate(requestParameters: LifecycleRulesPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LifecycleRule> {
        const response = await this.lifecycleRulesPartialUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/rules/{id}/`;
        urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));

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

    /**
     */
    async lifecycleRulesRetrieveRaw(requestParameters: LifecycleRulesRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LifecycleRule>> {
        const requestOptions = await this.lifecycleRulesRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     */
    async lifecycleRulesRetrieve(requestParameters: LifecycleRulesRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LifecycleRule> {
        const response = await this.lifecycleRulesRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/rules/{id}/`;
        urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));

        return {
            path: urlPath,
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: LifecycleRuleRequestToJSON(requestParameters['lifecycleRuleRequest']),
        };
    }

    /**
     */
    async lifecycleRulesUpdateRaw(requestParameters: LifecycleRulesUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LifecycleRule>> {
        const requestOptions = await this.lifecycleRulesUpdateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     */
    async lifecycleRulesUpdate(requestParameters: LifecycleRulesUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LifecycleRule> {
        const response = await this.lifecycleRulesUpdateRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/user_offboarding/`;

        return {
            path: urlPath,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UserOffboardingRequestToJSON(requestParameters['userOffboardingRequest']),
        };
    }

    /**
     */
    async lifecycleUserOffboardingCreateRaw(requestParameters: LifecycleUserOffboardingCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserOffboarding>> {
        const requestOptions = await this.lifecycleUserOffboardingCreateRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     */
    async lifecycleUserOffboardingCreate(requestParameters: LifecycleUserOffboardingCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserOffboarding> {
        const response = await this.lifecycleUserOffboardingCreateRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/user_offboarding/{id}/`;
        urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));

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

    /**
     * Cancel a pending offboarding instead of deleting the record.  The row is retained (as `CANCELED`) so the offboarding stays visible in the audit history; deletion would erase who scheduled and cancelled it. You cannot cancel an offboarding that targets you.
     */
    async lifecycleUserOffboardingDestroyRaw(requestParameters: LifecycleUserOffboardingDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const requestOptions = await this.lifecycleUserOffboardingDestroyRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Cancel a pending offboarding instead of deleting the record.  The row is retained (as `CANCELED`) so the offboarding stays visible in the audit history; deletion would erase who scheduled and cancelled it. You cannot cancel an offboarding that targets you.
     */
    async lifecycleUserOffboardingDestroy(requestParameters: LifecycleUserOffboardingDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.lifecycleUserOffboardingDestroyRaw(requestParameters, initOverrides);
    }

    /**
     * Creates request options for lifecycleUserOffboardingList without sending the request
     */
    async lifecycleUserOffboardingListRequestOpts(requestParameters: LifecycleUserOffboardingListRequest): Promise<runtime.RequestOpts> {
        const queryParameters: any = {};

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

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

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

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

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

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

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

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/user_offboarding/`;

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

    /**
     */
    async lifecycleUserOffboardingListRaw(requestParameters: LifecycleUserOffboardingListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedUserOffboardingList>> {
        const requestOptions = await this.lifecycleUserOffboardingListRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     */
    async lifecycleUserOffboardingList(requestParameters: LifecycleUserOffboardingListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedUserOffboardingList> {
        const response = await this.lifecycleUserOffboardingListRaw(requestParameters, initOverrides);
        return await response.value();
    }

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

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }

        let urlPath = `/lifecycle/user_offboarding/{id}/`;
        urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));

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

    /**
     */
    async lifecycleUserOffboardingRetrieveRaw(requestParameters: LifecycleUserOffboardingRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserOffboarding>> {
        const requestOptions = await this.lifecycleUserOffboardingRetrieveRequestOpts(requestParameters);
        const response = await this.request(requestOptions, initOverrides);

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

    /**
     */
    async lifecycleUserOffboardingRetrieve(requestParameters: LifecycleUserOffboardingRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserOffboarding> {
        const response = await this.lifecycleUserOffboardingRetrieveRaw(requestParameters, initOverrides);
        return await response.value();
    }

}