/* tslint:disable */
/* eslint-disable */
/**
 * Faraday REST API
 * The [Faraday](https://faraday.ai) API makes it easy to predict customer behavior programmatically. See our [API change policy](https://faraday.ai/legal).
 *
 * The version of the OpenAPI document: 1.0.0
 * Contact: support@faraday.ai
 *
 * 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 {
    ArchiveConfig,
    Persona,
    PersonaMergePatch,
    PersonaSet,
    PersonaSetAnalysisDimensions,
    PersonaSetAnalysisFlow,
    PersonaSetMergePatch,
    PersonaSetPost,
} from '../models';

export interface ArchivePersonaSetRequest {
    personaSetId: string;
    archiveConfig: ArchiveConfig;
}

export interface CreatePersonaSetRequest {
    personaSetPost: PersonaSetPost;
}

export interface DeletePersonaSetRequest {
    personaSetId: string;
}

export interface ForceUpdatePersonaSetRequest {
    personaSetId: string;
}

export interface GetPersonaSetRequest {
    personaSetId: string;
}

export interface GetPersonaSetAnalysisDimensionsRequest {
    personaSetId: string;
}

export interface GetPersonaSetAnalysisFlowRequest {
    personaSetId: string;
}

export interface GetPersonaSetsRequest {
    ids?: Array<string>;
}

export interface UnarchivePersonaSetRequest {
    personaSetId: string;
    archiveConfig: ArchiveConfig;
}

export interface UpdatePersonaRequest {
    personaSetId: string;
    personaId: string;
    personaFields: PersonaMergePatch;
}

export interface UpdatePersonaSetRequest {
    personaSetId: string;
    personaSetFields: PersonaSetMergePatch;
}

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

    /**
     * Archive a persona set
     * Archive a persona set
     */
    async archivePersonaSetRaw(requestParameters: ArchivePersonaSetRequest, ): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.personaSetId === null || requestParameters.personaSetId === undefined) {
            throw new runtime.RequiredError('personaSetId','Required parameter requestParameters.personaSetId was null or undefined when calling archivePersonaSet.');
        }

        if (requestParameters.archiveConfig === null || requestParameters.archiveConfig === undefined) {
            throw new runtime.RequiredError('archiveConfig','Required parameter requestParameters.archiveConfig was null or undefined when calling archivePersonaSet.');
        }

        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("bearer", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/persona_sets/{persona_set_id}/archive`.replace(`{${"persona_set_id"}}`, encodeURIComponent(String(requestParameters.personaSetId))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.archiveConfig,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Archive a persona set
     * Archive a persona set
     */
    async archivePersonaSet(personaSetId: string, archiveConfig: ArchiveConfig, ): Promise<void> {
        await this.archivePersonaSetRaw({ personaSetId: personaSetId, archiveConfig: archiveConfig }, );
    }

    /**
     * Invoke the build of a new persona set for a given cohort
     * Create persona set
     */
    async createPersonaSetRaw(requestParameters: CreatePersonaSetRequest, ): Promise<runtime.ApiResponse<PersonaSet>> {
        if (requestParameters.personaSetPost === null || requestParameters.personaSetPost === undefined) {
            throw new runtime.RequiredError('personaSetPost','Required parameter requestParameters.personaSetPost was null or undefined when calling createPersonaSet.');
        }

        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("bearer", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/persona_sets`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.personaSetPost,
        });

        return new runtime.JSONApiResponse(response);
    }

    /**
     * Invoke the build of a new persona set for a given cohort
     * Create persona set
     */
    async createPersonaSet(personaSetPost: PersonaSetPost, ): Promise<PersonaSet> {
        const response = await this.createPersonaSetRaw({ personaSetPost: personaSetPost }, );
        return await response.value();
    }

    /**
     * Delete a persona set
     */
    async deletePersonaSetRaw(requestParameters: DeletePersonaSetRequest, ): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.personaSetId === null || requestParameters.personaSetId === undefined) {
            throw new runtime.RequiredError('personaSetId','Required parameter requestParameters.personaSetId was null or undefined when calling deletePersonaSet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/persona_sets/{persona_set_id}`.replace(`{${"persona_set_id"}}`, encodeURIComponent(String(requestParameters.personaSetId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Delete a persona set
     */
    async deletePersonaSet(personaSetId: string, ): Promise<void> {
        await this.deletePersonaSetRaw({ personaSetId: personaSetId }, );
    }

    /**
     * Trigger a rerun for this resource. Faraday automatically updates resources when their config changes, but this option is available in case of transient errors. 
     * Trigger a rerun for this resource.
     */
    async forceUpdatePersonaSetRaw(requestParameters: ForceUpdatePersonaSetRequest, ): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.personaSetId === null || requestParameters.personaSetId === undefined) {
            throw new runtime.RequiredError('personaSetId','Required parameter requestParameters.personaSetId was null or undefined when calling forceUpdatePersonaSet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/persona_sets/{persona_set_id}/force_update`.replace(`{${"persona_set_id"}}`, encodeURIComponent(String(requestParameters.personaSetId))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Trigger a rerun for this resource. Faraday automatically updates resources when their config changes, but this option is available in case of transient errors. 
     * Trigger a rerun for this resource.
     */
    async forceUpdatePersonaSet(personaSetId: string, ): Promise<void> {
        await this.forceUpdatePersonaSetRaw({ personaSetId: personaSetId }, );
    }

    /**
     * Details on a specific persona set, including details on all of its constituent personas
     * Retrieve a persona set
     */
    async getPersonaSetRaw(requestParameters: GetPersonaSetRequest, ): Promise<runtime.ApiResponse<PersonaSet>> {
        if (requestParameters.personaSetId === null || requestParameters.personaSetId === undefined) {
            throw new runtime.RequiredError('personaSetId','Required parameter requestParameters.personaSetId was null or undefined when calling getPersonaSet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/persona_sets/{persona_set_id}`.replace(`{${"persona_set_id"}}`, encodeURIComponent(String(requestParameters.personaSetId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.JSONApiResponse(response);
    }

    /**
     * Details on a specific persona set, including details on all of its constituent personas
     * Retrieve a persona set
     */
    async getPersonaSet(personaSetId: string, ): Promise<PersonaSet> {
        const response = await this.getPersonaSetRaw({ personaSetId: personaSetId }, );
        return await response.value();
    }

    /**
     * Get various trait breakdown information about a persona set.
     */
    async getPersonaSetAnalysisDimensionsRaw(requestParameters: GetPersonaSetAnalysisDimensionsRequest, ): Promise<runtime.ApiResponse<Array<PersonaSetAnalysisDimensions>>> {
        if (requestParameters.personaSetId === null || requestParameters.personaSetId === undefined) {
            throw new runtime.RequiredError('personaSetId','Required parameter requestParameters.personaSetId was null or undefined when calling getPersonaSetAnalysisDimensions.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/persona_sets/{persona_set_id}/analysis/dimensions`.replace(`{${"persona_set_id"}}`, encodeURIComponent(String(requestParameters.personaSetId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.JSONApiResponse(response);
    }

    /**
     * Get various trait breakdown information about a persona set.
     */
    async getPersonaSetAnalysisDimensions(personaSetId: string, ): Promise<Array<PersonaSetAnalysisDimensions>> {
        const response = await this.getPersonaSetAnalysisDimensionsRaw({ personaSetId: personaSetId }, );
        return await response.value();
    }

    /**
     * Get various flow of persona sets over time.
     */
    async getPersonaSetAnalysisFlowRaw(requestParameters: GetPersonaSetAnalysisFlowRequest, ): Promise<runtime.ApiResponse<PersonaSetAnalysisFlow>> {
        if (requestParameters.personaSetId === null || requestParameters.personaSetId === undefined) {
            throw new runtime.RequiredError('personaSetId','Required parameter requestParameters.personaSetId was null or undefined when calling getPersonaSetAnalysisFlow.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/persona_sets/{persona_set_id}/analysis/flow`.replace(`{${"persona_set_id"}}`, encodeURIComponent(String(requestParameters.personaSetId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        });

        return new runtime.JSONApiResponse(response);
    }

    /**
     * Get various flow of persona sets over time.
     */
    async getPersonaSetAnalysisFlow(personaSetId: string, ): Promise<PersonaSetAnalysisFlow> {
        const response = await this.getPersonaSetAnalysisFlowRaw({ personaSetId: personaSetId }, );
        return await response.value();
    }

    /**
     * A list of available persona sets
     * List persona sets
     */
    async getPersonaSetsRaw(requestParameters: GetPersonaSetsRequest, ): Promise<runtime.ApiResponse<Array<PersonaSet>>> {
        const queryParameters: any = {};

        if (requestParameters.ids) {
            queryParameters['ids'] = requestParameters.ids;
        }

        const headerParameters: runtime.HTTPHeaders = {};

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

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

        return new runtime.JSONApiResponse(response);
    }

    /**
     * A list of available persona sets
     * List persona sets
     */
    async getPersonaSets(ids?: Array<string>, ): Promise<Array<PersonaSet>> {
        const response = await this.getPersonaSetsRaw({ ids: ids }, );
        return await response.value();
    }

    /**
     * Unarchive a persona set
     * Unarchive a persona set
     */
    async unarchivePersonaSetRaw(requestParameters: UnarchivePersonaSetRequest, ): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.personaSetId === null || requestParameters.personaSetId === undefined) {
            throw new runtime.RequiredError('personaSetId','Required parameter requestParameters.personaSetId was null or undefined when calling unarchivePersonaSet.');
        }

        if (requestParameters.archiveConfig === null || requestParameters.archiveConfig === undefined) {
            throw new runtime.RequiredError('archiveConfig','Required parameter requestParameters.archiveConfig was null or undefined when calling unarchivePersonaSet.');
        }

        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("bearer", []);

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/persona_sets/{persona_set_id}/unarchive`.replace(`{${"persona_set_id"}}`, encodeURIComponent(String(requestParameters.personaSetId))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.archiveConfig,
        });

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Unarchive a persona set
     * Unarchive a persona set
     */
    async unarchivePersonaSet(personaSetId: string, archiveConfig: ArchiveConfig, ): Promise<void> {
        await this.unarchivePersonaSetRaw({ personaSetId: personaSetId, archiveConfig: archiveConfig }, );
    }

    /**
     * Edit a persona
     * Edit a persona
     */
    async updatePersonaRaw(requestParameters: UpdatePersonaRequest, ): Promise<runtime.ApiResponse<Persona>> {
        if (requestParameters.personaSetId === null || requestParameters.personaSetId === undefined) {
            throw new runtime.RequiredError('personaSetId','Required parameter requestParameters.personaSetId was null or undefined when calling updatePersona.');
        }

        if (requestParameters.personaId === null || requestParameters.personaId === undefined) {
            throw new runtime.RequiredError('personaId','Required parameter requestParameters.personaId was null or undefined when calling updatePersona.');
        }

        if (requestParameters.personaFields === null || requestParameters.personaFields === undefined) {
            throw new runtime.RequiredError('personaFields','Required parameter requestParameters.personaFields was null or undefined when calling updatePersona.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/persona_sets/{persona_set_id}/personas/{persona_id}`.replace(`{${"persona_set_id"}}`, encodeURIComponent(String(requestParameters.personaSetId))).replace(`{${"persona_id"}}`, encodeURIComponent(String(requestParameters.personaId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.personaFields,
        });

        return new runtime.JSONApiResponse(response);
    }

    /**
     * Edit a persona
     * Edit a persona
     */
    async updatePersona(personaSetId: string, personaId: string, personaFields: PersonaMergePatch, ): Promise<Persona> {
        const response = await this.updatePersonaRaw({ personaSetId: personaSetId, personaId: personaId, personaFields: personaFields }, );
        return await response.value();
    }

    /**
     * Edit a persona set
     * Edit a persona set
     */
    async updatePersonaSetRaw(requestParameters: UpdatePersonaSetRequest, ): Promise<runtime.ApiResponse<PersonaSet>> {
        if (requestParameters.personaSetId === null || requestParameters.personaSetId === undefined) {
            throw new runtime.RequiredError('personaSetId','Required parameter requestParameters.personaSetId was null or undefined when calling updatePersonaSet.');
        }

        if (requestParameters.personaSetFields === null || requestParameters.personaSetFields === undefined) {
            throw new runtime.RequiredError('personaSetFields','Required parameter requestParameters.personaSetFields was null or undefined when calling updatePersonaSet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

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

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

            if (tokenString) {
                headerParameters["Authorization"] = `Bearer ${tokenString}`;
            }
        }
        const response = await this.request({
            path: `/persona_sets/{persona_set_id}`.replace(`{${"persona_set_id"}}`, encodeURIComponent(String(requestParameters.personaSetId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.personaSetFields,
        });

        return new runtime.JSONApiResponse(response);
    }

    /**
     * Edit a persona set
     * Edit a persona set
     */
    async updatePersonaSet(personaSetId: string, personaSetFields: PersonaSetMergePatch, ): Promise<PersonaSet> {
        const response = await this.updatePersonaSetRaw({ personaSetId: personaSetId, personaSetFields: personaSetFields }, );
        return await response.value();
    }

}