@bitblit/ratchet-misc/lib/brevo/generated/apis/ContactsApi.js

Ratchet miscellaneous tooling that requires smallish dependant libraries

import * as runtime from '../runtime.js';
import { AddContactToListToJSON, CreateAttributeToJSON, CreateContactToJSON, CreateDoiContactToJSON, CreatedProcessIdFromJSON, CreateListToJSON, CreateModelFromJSON, CreateUpdateContactModelFromJSON, CreateUpdateFolderToJSON, GetAttributesFromJSON, GetContactCampaignStatsFromJSON, GetContactsFromJSON, GetExtendedContactDetailsFromJSON, GetExtendedListFromJSON, GetFolderFromJSON, GetFolderListsFromJSON, GetFoldersFromJSON, GetListsFromJSON, GetSegmentsFromJSON, PostContactInfoFromJSON, RemoveContactFromListToJSON, RequestContactExportToJSON, RequestContactImportToJSON, UpdateAttributeToJSON, UpdateContactToJSON, UpdateListToJSON, } from '../models/index.js';
export class ContactsApi extends runtime.BaseAPI {
    async addContactToListRaw(requestParameters, initOverrides) {
        if (requestParameters.listId === null || requestParameters.listId === undefined) {
            throw new runtime.RequiredError('listId', 'Required parameter requestParameters.listId was null or undefined when calling addContactToList.');
        }
        if (requestParameters.contactEmails === null || requestParameters.contactEmails === undefined) {
            throw new runtime.RequiredError('contactEmails', 'Required parameter requestParameters.contactEmails was null or undefined when calling addContactToList.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/lists/{listId}/contacts/add`.replace(`{${'listId'}}`, encodeURIComponent(String(requestParameters.listId))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AddContactToListToJSON(requestParameters.contactEmails),
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => PostContactInfoFromJSON(jsonValue));
    }
    async addContactToList(requestParameters, initOverrides) {
        const response = await this.addContactToListRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async createAttributeRaw(requestParameters, initOverrides) {
        if (requestParameters.attributeCategory === null || requestParameters.attributeCategory === undefined) {
            throw new runtime.RequiredError('attributeCategory', 'Required parameter requestParameters.attributeCategory was null or undefined when calling createAttribute.');
        }
        if (requestParameters.attributeName === null || requestParameters.attributeName === undefined) {
            throw new runtime.RequiredError('attributeName', 'Required parameter requestParameters.attributeName was null or undefined when calling createAttribute.');
        }
        if (requestParameters.createAttribute === null || requestParameters.createAttribute === undefined) {
            throw new runtime.RequiredError('createAttribute', 'Required parameter requestParameters.createAttribute was null or undefined when calling createAttribute.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/attributes/{attributeCategory}/{attributeName}`
                .replace(`{${'attributeCategory'}}`, encodeURIComponent(String(requestParameters.attributeCategory)))
                .replace(`{${'attributeName'}}`, encodeURIComponent(String(requestParameters.attributeName))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateAttributeToJSON(requestParameters.createAttribute),
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async createAttribute(requestParameters, initOverrides) {
        await this.createAttributeRaw(requestParameters, initOverrides);
    }
    async createContactRaw(requestParameters, initOverrides) {
        if (requestParameters.createContact === null || requestParameters.createContact === undefined) {
            throw new runtime.RequiredError('createContact', 'Required parameter requestParameters.createContact was null or undefined when calling createContact.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateContactToJSON(requestParameters.createContact),
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => CreateUpdateContactModelFromJSON(jsonValue));
    }
    async createContact(requestParameters, initOverrides) {
        const response = await this.createContactRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async createDoiContactRaw(requestParameters, initOverrides) {
        if (requestParameters.createDoiContact === null || requestParameters.createDoiContact === undefined) {
            throw new runtime.RequiredError('createDoiContact', 'Required parameter requestParameters.createDoiContact was null or undefined when calling createDoiContact.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/doubleOptinConfirmation`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateDoiContactToJSON(requestParameters.createDoiContact),
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async createDoiContact(requestParameters, initOverrides) {
        await this.createDoiContactRaw(requestParameters, initOverrides);
    }
    async createFolderRaw(requestParameters, initOverrides) {
        if (requestParameters.createFolder === null || requestParameters.createFolder === undefined) {
            throw new runtime.RequiredError('createFolder', 'Required parameter requestParameters.createFolder was null or undefined when calling createFolder.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/folders`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateUpdateFolderToJSON(requestParameters.createFolder),
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => CreateModelFromJSON(jsonValue));
    }
    async createFolder(requestParameters, initOverrides) {
        const response = await this.createFolderRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async createListRaw(requestParameters, initOverrides) {
        if (requestParameters.createList === null || requestParameters.createList === undefined) {
            throw new runtime.RequiredError('createList', 'Required parameter requestParameters.createList was null or undefined when calling createList.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/lists`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateListToJSON(requestParameters.createList),
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => CreateModelFromJSON(jsonValue));
    }
    async createList(requestParameters, initOverrides) {
        const response = await this.createListRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async deleteAttributeRaw(requestParameters, initOverrides) {
        if (requestParameters.attributeCategory === null || requestParameters.attributeCategory === undefined) {
            throw new runtime.RequiredError('attributeCategory', 'Required parameter requestParameters.attributeCategory was null or undefined when calling deleteAttribute.');
        }
        if (requestParameters.attributeName === null || requestParameters.attributeName === undefined) {
            throw new runtime.RequiredError('attributeName', 'Required parameter requestParameters.attributeName was null or undefined when calling deleteAttribute.');
        }
        const queryParameters = {};
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/attributes/{attributeCategory}/{attributeName}`
                .replace(`{${'attributeCategory'}}`, encodeURIComponent(String(requestParameters.attributeCategory)))
                .replace(`{${'attributeName'}}`, encodeURIComponent(String(requestParameters.attributeName))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async deleteAttribute(requestParameters, initOverrides) {
        await this.deleteAttributeRaw(requestParameters, initOverrides);
    }
    async deleteContactRaw(requestParameters, initOverrides) {
        if (requestParameters.email === null || requestParameters.email === undefined) {
            throw new runtime.RequiredError('email', 'Required parameter requestParameters.email was null or undefined when calling deleteContact.');
        }
        const queryParameters = {};
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/{email}`.replace(`{${'email'}}`, encodeURIComponent(String(requestParameters.email))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async deleteContact(requestParameters, initOverrides) {
        await this.deleteContactRaw(requestParameters, initOverrides);
    }
    async deleteFolderRaw(requestParameters, initOverrides) {
        if (requestParameters.folderId === null || requestParameters.folderId === undefined) {
            throw new runtime.RequiredError('folderId', 'Required parameter requestParameters.folderId was null or undefined when calling deleteFolder.');
        }
        const queryParameters = {};
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/folders/{folderId}`.replace(`{${'folderId'}}`, encodeURIComponent(String(requestParameters.folderId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async deleteFolder(requestParameters, initOverrides) {
        await this.deleteFolderRaw(requestParameters, initOverrides);
    }
    async deleteListRaw(requestParameters, initOverrides) {
        if (requestParameters.listId === null || requestParameters.listId === undefined) {
            throw new runtime.RequiredError('listId', 'Required parameter requestParameters.listId was null or undefined when calling deleteList.');
        }
        const queryParameters = {};
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/lists/{listId}`.replace(`{${'listId'}}`, encodeURIComponent(String(requestParameters.listId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async deleteList(requestParameters, initOverrides) {
        await this.deleteListRaw(requestParameters, initOverrides);
    }
    async getAttributesRaw(initOverrides) {
        const queryParameters = {};
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/attributes`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetAttributesFromJSON(jsonValue));
    }
    async getAttributes(initOverrides) {
        const response = await this.getAttributesRaw(initOverrides);
        return await response.value();
    }
    async getContactInfoRaw(requestParameters, initOverrides) {
        if (requestParameters.email === null || requestParameters.email === undefined) {
            throw new runtime.RequiredError('email', 'Required parameter requestParameters.email was null or undefined when calling getContactInfo.');
        }
        const queryParameters = {};
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/{email}`.replace(`{${'email'}}`, encodeURIComponent(String(requestParameters.email))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetExtendedContactDetailsFromJSON(jsonValue));
    }
    async getContactInfo(requestParameters, initOverrides) {
        const response = await this.getContactInfoRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getContactStatsRaw(requestParameters, initOverrides) {
        if (requestParameters.email === null || requestParameters.email === undefined) {
            throw new runtime.RequiredError('email', 'Required parameter requestParameters.email was null or undefined when calling getContactStats.');
        }
        const queryParameters = {};
        if (requestParameters.startDate !== undefined) {
            queryParameters['startDate'] = requestParameters.startDate.toISOString().substring(0, 10);
        }
        if (requestParameters.endDate !== undefined) {
            queryParameters['endDate'] = requestParameters.endDate.toISOString().substring(0, 10);
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/{email}/campaignStats`.replace(`{${'email'}}`, encodeURIComponent(String(requestParameters.email))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetContactCampaignStatsFromJSON(jsonValue));
    }
    async getContactStats(requestParameters, initOverrides) {
        const response = await this.getContactStatsRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getContactsRaw(requestParameters, initOverrides) {
        const queryParameters = {};
        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }
        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }
        if (requestParameters.modifiedSince !== undefined) {
            queryParameters['modifiedSince'] = requestParameters.modifiedSince.toISOString();
        }
        if (requestParameters.createdSince !== undefined) {
            queryParameters['createdSince'] = requestParameters.createdSince.toISOString();
        }
        if (requestParameters.sort !== undefined) {
            queryParameters['sort'] = requestParameters.sort;
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetContactsFromJSON(jsonValue));
    }
    async getContacts(requestParameters = {}, initOverrides) {
        const response = await this.getContactsRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getContactsFromListRaw(requestParameters, initOverrides) {
        if (requestParameters.listId === null || requestParameters.listId === undefined) {
            throw new runtime.RequiredError('listId', 'Required parameter requestParameters.listId was null or undefined when calling getContactsFromList.');
        }
        const queryParameters = {};
        if (requestParameters.modifiedSince !== undefined) {
            queryParameters['modifiedSince'] = requestParameters.modifiedSince.toISOString();
        }
        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }
        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }
        if (requestParameters.sort !== undefined) {
            queryParameters['sort'] = requestParameters.sort;
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/lists/{listId}/contacts`.replace(`{${'listId'}}`, encodeURIComponent(String(requestParameters.listId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetContactsFromJSON(jsonValue));
    }
    async getContactsFromList(requestParameters, initOverrides) {
        const response = await this.getContactsFromListRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getFolderRaw(requestParameters, initOverrides) {
        if (requestParameters.folderId === null || requestParameters.folderId === undefined) {
            throw new runtime.RequiredError('folderId', 'Required parameter requestParameters.folderId was null or undefined when calling getFolder.');
        }
        const queryParameters = {};
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/folders/{folderId}`.replace(`{${'folderId'}}`, encodeURIComponent(String(requestParameters.folderId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetFolderFromJSON(jsonValue));
    }
    async getFolder(requestParameters, initOverrides) {
        const response = await this.getFolderRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getFolderListsRaw(requestParameters, initOverrides) {
        if (requestParameters.folderId === null || requestParameters.folderId === undefined) {
            throw new runtime.RequiredError('folderId', 'Required parameter requestParameters.folderId was null or undefined when calling getFolderLists.');
        }
        const queryParameters = {};
        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }
        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }
        if (requestParameters.sort !== undefined) {
            queryParameters['sort'] = requestParameters.sort;
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/folders/{folderId}/lists`.replace(`{${'folderId'}}`, encodeURIComponent(String(requestParameters.folderId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetFolderListsFromJSON(jsonValue));
    }
    async getFolderLists(requestParameters, initOverrides) {
        const response = await this.getFolderListsRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getFoldersRaw(requestParameters, initOverrides) {
        if (requestParameters.limit === null || requestParameters.limit === undefined) {
            throw new runtime.RequiredError('limit', 'Required parameter requestParameters.limit was null or undefined when calling getFolders.');
        }
        if (requestParameters.offset === null || requestParameters.offset === undefined) {
            throw new runtime.RequiredError('offset', 'Required parameter requestParameters.offset was null or undefined when calling getFolders.');
        }
        const queryParameters = {};
        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }
        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }
        if (requestParameters.sort !== undefined) {
            queryParameters['sort'] = requestParameters.sort;
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/folders`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetFoldersFromJSON(jsonValue));
    }
    async getFolders(requestParameters, initOverrides) {
        const response = await this.getFoldersRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getListRaw(requestParameters, initOverrides) {
        if (requestParameters.listId === null || requestParameters.listId === undefined) {
            throw new runtime.RequiredError('listId', 'Required parameter requestParameters.listId was null or undefined when calling getList.');
        }
        const queryParameters = {};
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/lists/{listId}`.replace(`{${'listId'}}`, encodeURIComponent(String(requestParameters.listId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetExtendedListFromJSON(jsonValue));
    }
    async getList(requestParameters, initOverrides) {
        const response = await this.getListRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getListsRaw(requestParameters, initOverrides) {
        const queryParameters = {};
        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }
        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }
        if (requestParameters.sort !== undefined) {
            queryParameters['sort'] = requestParameters.sort;
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/lists`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetListsFromJSON(jsonValue));
    }
    async getLists(requestParameters = {}, initOverrides) {
        const response = await this.getListsRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getSegmentsRaw(requestParameters, initOverrides) {
        if (requestParameters.limit === null || requestParameters.limit === undefined) {
            throw new runtime.RequiredError('limit', 'Required parameter requestParameters.limit was null or undefined when calling getSegments.');
        }
        if (requestParameters.offset === null || requestParameters.offset === undefined) {
            throw new runtime.RequiredError('offset', 'Required parameter requestParameters.offset was null or undefined when calling getSegments.');
        }
        const queryParameters = {};
        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }
        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }
        if (requestParameters.sort !== undefined) {
            queryParameters['sort'] = requestParameters.sort;
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/segments`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetSegmentsFromJSON(jsonValue));
    }
    async getSegments(requestParameters, initOverrides) {
        const response = await this.getSegmentsRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async importContactsRaw(requestParameters, initOverrides) {
        if (requestParameters.requestContactImport === null || requestParameters.requestContactImport === undefined) {
            throw new runtime.RequiredError('requestContactImport', 'Required parameter requestParameters.requestContactImport was null or undefined when calling importContacts.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/import`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RequestContactImportToJSON(requestParameters.requestContactImport),
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => CreatedProcessIdFromJSON(jsonValue));
    }
    async importContacts(requestParameters, initOverrides) {
        const response = await this.importContactsRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async removeContactFromListRaw(requestParameters, initOverrides) {
        if (requestParameters.listId === null || requestParameters.listId === undefined) {
            throw new runtime.RequiredError('listId', 'Required parameter requestParameters.listId was null or undefined when calling removeContactFromList.');
        }
        if (requestParameters.contactEmails === null || requestParameters.contactEmails === undefined) {
            throw new runtime.RequiredError('contactEmails', 'Required parameter requestParameters.contactEmails was null or undefined when calling removeContactFromList.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/lists/{listId}/contacts/remove`.replace(`{${'listId'}}`, encodeURIComponent(String(requestParameters.listId))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RemoveContactFromListToJSON(requestParameters.contactEmails),
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => PostContactInfoFromJSON(jsonValue));
    }
    async removeContactFromList(requestParameters, initOverrides) {
        const response = await this.removeContactFromListRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async requestContactExportRaw(requestParameters, initOverrides) {
        if (requestParameters.requestContactExport === null || requestParameters.requestContactExport === undefined) {
            throw new runtime.RequiredError('requestContactExport', 'Required parameter requestParameters.requestContactExport was null or undefined when calling requestContactExport.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/export`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RequestContactExportToJSON(requestParameters.requestContactExport),
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => CreatedProcessIdFromJSON(jsonValue));
    }
    async requestContactExport(requestParameters, initOverrides) {
        const response = await this.requestContactExportRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async updateAttributeRaw(requestParameters, initOverrides) {
        if (requestParameters.attributeCategory === null || requestParameters.attributeCategory === undefined) {
            throw new runtime.RequiredError('attributeCategory', 'Required parameter requestParameters.attributeCategory was null or undefined when calling updateAttribute.');
        }
        if (requestParameters.attributeName === null || requestParameters.attributeName === undefined) {
            throw new runtime.RequiredError('attributeName', 'Required parameter requestParameters.attributeName was null or undefined when calling updateAttribute.');
        }
        if (requestParameters.updateAttribute === null || requestParameters.updateAttribute === undefined) {
            throw new runtime.RequiredError('updateAttribute', 'Required parameter requestParameters.updateAttribute was null or undefined when calling updateAttribute.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/attributes/{attributeCategory}/{attributeName}`
                .replace(`{${'attributeCategory'}}`, encodeURIComponent(String(requestParameters.attributeCategory)))
                .replace(`{${'attributeName'}}`, encodeURIComponent(String(requestParameters.attributeName))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UpdateAttributeToJSON(requestParameters.updateAttribute),
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async updateAttribute(requestParameters, initOverrides) {
        await this.updateAttributeRaw(requestParameters, initOverrides);
    }
    async updateContactRaw(requestParameters, initOverrides) {
        if (requestParameters.email === null || requestParameters.email === undefined) {
            throw new runtime.RequiredError('email', 'Required parameter requestParameters.email was null or undefined when calling updateContact.');
        }
        if (requestParameters.updateContact === null || requestParameters.updateContact === undefined) {
            throw new runtime.RequiredError('updateContact', 'Required parameter requestParameters.updateContact was null or undefined when calling updateContact.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/{email}`.replace(`{${'email'}}`, encodeURIComponent(String(requestParameters.email))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UpdateContactToJSON(requestParameters.updateContact),
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async updateContact(requestParameters, initOverrides) {
        await this.updateContactRaw(requestParameters, initOverrides);
    }
    async updateFolderRaw(requestParameters, initOverrides) {
        if (requestParameters.folderId === null || requestParameters.folderId === undefined) {
            throw new runtime.RequiredError('folderId', 'Required parameter requestParameters.folderId was null or undefined when calling updateFolder.');
        }
        if (requestParameters.updateFolder === null || requestParameters.updateFolder === undefined) {
            throw new runtime.RequiredError('updateFolder', 'Required parameter requestParameters.updateFolder was null or undefined when calling updateFolder.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/folders/{folderId}`.replace(`{${'folderId'}}`, encodeURIComponent(String(requestParameters.folderId))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: CreateUpdateFolderToJSON(requestParameters.updateFolder),
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async updateFolder(requestParameters, initOverrides) {
        await this.updateFolderRaw(requestParameters, initOverrides);
    }
    async updateListRaw(requestParameters, initOverrides) {
        if (requestParameters.listId === null || requestParameters.listId === undefined) {
            throw new runtime.RequiredError('listId', 'Required parameter requestParameters.listId was null or undefined when calling updateList.');
        }
        if (requestParameters.updateList === null || requestParameters.updateList === undefined) {
            throw new runtime.RequiredError('updateList', 'Required parameter requestParameters.updateList was null or undefined when calling updateList.');
        }
        const queryParameters = {};
        const headerParameters = {};
        headerParameters['Content-Type'] = 'application/json';
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/contacts/lists/{listId}`.replace(`{${'listId'}}`, encodeURIComponent(String(requestParameters.listId))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UpdateListToJSON(requestParameters.updateList),
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async updateList(requestParameters, initOverrides) {
        await this.updateListRaw(requestParameters, initOverrides);
    }
}
export var CreateAttributeAttributeCategoryEnum;
(function (CreateAttributeAttributeCategoryEnum) {
    CreateAttributeAttributeCategoryEnum["Normal"] = "normal";
    CreateAttributeAttributeCategoryEnum["Transactional"] = "transactional";
    CreateAttributeAttributeCategoryEnum["Category"] = "category";
    CreateAttributeAttributeCategoryEnum["Calculated"] = "calculated";
    CreateAttributeAttributeCategoryEnum["Global"] = "global";
})(CreateAttributeAttributeCategoryEnum || (CreateAttributeAttributeCategoryEnum = {}));
export var DeleteAttributeAttributeCategoryEnum;
(function (DeleteAttributeAttributeCategoryEnum) {
    DeleteAttributeAttributeCategoryEnum["Normal"] = "normal";
    DeleteAttributeAttributeCategoryEnum["Transactional"] = "transactional";
    DeleteAttributeAttributeCategoryEnum["Category"] = "category";
    DeleteAttributeAttributeCategoryEnum["Calculated"] = "calculated";
    DeleteAttributeAttributeCategoryEnum["Global"] = "global";
})(DeleteAttributeAttributeCategoryEnum || (DeleteAttributeAttributeCategoryEnum = {}));
export var GetContactsSortEnum;
(function (GetContactsSortEnum) {
    GetContactsSortEnum["Asc"] = "asc";
    GetContactsSortEnum["Desc"] = "desc";
})(GetContactsSortEnum || (GetContactsSortEnum = {}));
export var GetContactsFromListSortEnum;
(function (GetContactsFromListSortEnum) {
    GetContactsFromListSortEnum["Asc"] = "asc";
    GetContactsFromListSortEnum["Desc"] = "desc";
})(GetContactsFromListSortEnum || (GetContactsFromListSortEnum = {}));
export var GetFolderListsSortEnum;
(function (GetFolderListsSortEnum) {
    GetFolderListsSortEnum["Asc"] = "asc";
    GetFolderListsSortEnum["Desc"] = "desc";
})(GetFolderListsSortEnum || (GetFolderListsSortEnum = {}));
export var GetFoldersSortEnum;
(function (GetFoldersSortEnum) {
    GetFoldersSortEnum["Asc"] = "asc";
    GetFoldersSortEnum["Desc"] = "desc";
})(GetFoldersSortEnum || (GetFoldersSortEnum = {}));
export var GetListsSortEnum;
(function (GetListsSortEnum) {
    GetListsSortEnum["Asc"] = "asc";
    GetListsSortEnum["Desc"] = "desc";
})(GetListsSortEnum || (GetListsSortEnum = {}));
export var GetSegmentsSortEnum;
(function (GetSegmentsSortEnum) {
    GetSegmentsSortEnum["Asc"] = "asc";
    GetSegmentsSortEnum["Desc"] = "desc";
})(GetSegmentsSortEnum || (GetSegmentsSortEnum = {}));
export var UpdateAttributeAttributeCategoryEnum;
(function (UpdateAttributeAttributeCategoryEnum) {
    UpdateAttributeAttributeCategoryEnum["Category"] = "category";
    UpdateAttributeAttributeCategoryEnum["Calculated"] = "calculated";
    UpdateAttributeAttributeCategoryEnum["Global"] = "global";
})(UpdateAttributeAttributeCategoryEnum || (UpdateAttributeAttributeCategoryEnum = {}));
//# sourceMappingURL=ContactsApi.js.map