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

Ratchet miscellaneous tooling that requires smallish dependant libraries

import * as runtime from '../runtime.js';
import { BlockDomainToJSON, CreateModelFromJSON, CreateSmtpEmailFromJSON, CreateSmtpTemplateToJSON, DeleteHardbouncesToJSON, GetAggregatedReportFromJSON, GetBlockedDomainsFromJSON, GetEmailEventReportFromJSON, GetReportsFromJSON, GetSmtpTemplateOverviewFromJSON, GetSmtpTemplatesFromJSON, GetTransacBlockedContactsFromJSON, GetTransacEmailContentFromJSON, GetTransacEmailsListFromJSON, SendEmailToJSON, SendSmtpEmailToJSON, SendTemplateEmailFromJSON, SendTestEmailToJSON, UpdateSmtpTemplateToJSON, } from '../models/index.js';
export class SMTPApi extends runtime.BaseAPI {
    async blockNewDomainRaw(requestParameters, initOverrides) {
        if (requestParameters.blockDomain === null || requestParameters.blockDomain === undefined) {
            throw new runtime.RequiredError('blockDomain', 'Required parameter requestParameters.blockDomain was null or undefined when calling blockNewDomain.');
        }
        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: `/smtp/blockedDomains`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: BlockDomainToJSON(requestParameters.blockDomain),
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async blockNewDomain(requestParameters, initOverrides) {
        await this.blockNewDomainRaw(requestParameters, initOverrides);
    }
    async createSmtpTemplateRaw(requestParameters, initOverrides) {
        if (requestParameters.smtpTemplate === null || requestParameters.smtpTemplate === undefined) {
            throw new runtime.RequiredError('smtpTemplate', 'Required parameter requestParameters.smtpTemplate was null or undefined when calling createSmtpTemplate.');
        }
        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: `/smtp/templates`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateSmtpTemplateToJSON(requestParameters.smtpTemplate),
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => CreateModelFromJSON(jsonValue));
    }
    async createSmtpTemplate(requestParameters, initOverrides) {
        const response = await this.createSmtpTemplateRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async deleteBlockedDomainRaw(requestParameters, initOverrides) {
        if (requestParameters.domain === null || requestParameters.domain === undefined) {
            throw new runtime.RequiredError('domain', 'Required parameter requestParameters.domain was null or undefined when calling deleteBlockedDomain.');
        }
        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: `/smtp/blockedDomains/{domain}`.replace(`{${'domain'}}`, encodeURIComponent(String(requestParameters.domain))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async deleteBlockedDomain(requestParameters, initOverrides) {
        await this.deleteBlockedDomainRaw(requestParameters, initOverrides);
    }
    async deleteHardbouncesRaw(requestParameters, initOverrides) {
        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: `/smtp/deleteHardbounces`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: DeleteHardbouncesToJSON(requestParameters.deleteHardbounces),
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async deleteHardbounces(requestParameters = {}, initOverrides) {
        await this.deleteHardbouncesRaw(requestParameters, initOverrides);
    }
    async deleteSmtpTemplateRaw(requestParameters, initOverrides) {
        if (requestParameters.templateId === null || requestParameters.templateId === undefined) {
            throw new runtime.RequiredError('templateId', 'Required parameter requestParameters.templateId was null or undefined when calling deleteSmtpTemplate.');
        }
        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: `/smtp/templates/{templateId}`.replace(`{${'templateId'}}`, encodeURIComponent(String(requestParameters.templateId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async deleteSmtpTemplate(requestParameters, initOverrides) {
        await this.deleteSmtpTemplateRaw(requestParameters, initOverrides);
    }
    async getAggregatedSmtpReportRaw(requestParameters, initOverrides) {
        const queryParameters = {};
        if (requestParameters.startDate !== undefined) {
            queryParameters['startDate'] = requestParameters.startDate;
        }
        if (requestParameters.endDate !== undefined) {
            queryParameters['endDate'] = requestParameters.endDate;
        }
        if (requestParameters.days !== undefined) {
            queryParameters['days'] = requestParameters.days;
        }
        if (requestParameters.tag !== undefined) {
            queryParameters['tag'] = requestParameters.tag;
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/smtp/statistics/aggregatedReport`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetAggregatedReportFromJSON(jsonValue));
    }
    async getAggregatedSmtpReport(requestParameters = {}, initOverrides) {
        const response = await this.getAggregatedSmtpReportRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getBlockedDomainsRaw(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: `/smtp/blockedDomains`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetBlockedDomainsFromJSON(jsonValue));
    }
    async getBlockedDomains(initOverrides) {
        const response = await this.getBlockedDomainsRaw(initOverrides);
        return await response.value();
    }
    async getEmailEventReportRaw(requestParameters, initOverrides) {
        const queryParameters = {};
        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }
        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }
        if (requestParameters.startDate !== undefined) {
            queryParameters['startDate'] = requestParameters.startDate;
        }
        if (requestParameters.endDate !== undefined) {
            queryParameters['endDate'] = requestParameters.endDate;
        }
        if (requestParameters.days !== undefined) {
            queryParameters['days'] = requestParameters.days;
        }
        if (requestParameters.email !== undefined) {
            queryParameters['email'] = requestParameters.email;
        }
        if (requestParameters.event !== undefined) {
            queryParameters['event'] = requestParameters.event;
        }
        if (requestParameters.tags !== undefined) {
            queryParameters['tags'] = requestParameters.tags;
        }
        if (requestParameters.messageId !== undefined) {
            queryParameters['messageId'] = requestParameters.messageId;
        }
        if (requestParameters.templateId !== undefined) {
            queryParameters['templateId'] = requestParameters.templateId;
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/smtp/statistics/events`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetEmailEventReportFromJSON(jsonValue));
    }
    async getEmailEventReport(requestParameters = {}, initOverrides) {
        const response = await this.getEmailEventReportRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getSmtpReportRaw(requestParameters, initOverrides) {
        const queryParameters = {};
        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }
        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }
        if (requestParameters.startDate !== undefined) {
            queryParameters['startDate'] = requestParameters.startDate;
        }
        if (requestParameters.endDate !== undefined) {
            queryParameters['endDate'] = requestParameters.endDate;
        }
        if (requestParameters.days !== undefined) {
            queryParameters['days'] = requestParameters.days;
        }
        if (requestParameters.tag !== undefined) {
            queryParameters['tag'] = requestParameters.tag;
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/smtp/statistics/reports`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetReportsFromJSON(jsonValue));
    }
    async getSmtpReport(requestParameters = {}, initOverrides) {
        const response = await this.getSmtpReportRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getSmtpTemplateRaw(requestParameters, initOverrides) {
        if (requestParameters.templateId === null || requestParameters.templateId === undefined) {
            throw new runtime.RequiredError('templateId', 'Required parameter requestParameters.templateId was null or undefined when calling getSmtpTemplate.');
        }
        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: `/smtp/templates/{templateId}`.replace(`{${'templateId'}}`, encodeURIComponent(String(requestParameters.templateId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetSmtpTemplateOverviewFromJSON(jsonValue));
    }
    async getSmtpTemplate(requestParameters, initOverrides) {
        const response = await this.getSmtpTemplateRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getSmtpTemplatesRaw(requestParameters, initOverrides) {
        const queryParameters = {};
        if (requestParameters.templateStatus !== undefined) {
            queryParameters['templateStatus'] = requestParameters.templateStatus;
        }
        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }
        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/smtp/templates`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetSmtpTemplatesFromJSON(jsonValue));
    }
    async getSmtpTemplates(requestParameters = {}, initOverrides) {
        const response = await this.getSmtpTemplatesRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getTransacBlockedContactsRaw(requestParameters, initOverrides) {
        const queryParameters = {};
        if (requestParameters.startDate !== undefined) {
            queryParameters['startDate'] = requestParameters.startDate;
        }
        if (requestParameters.endDate !== undefined) {
            queryParameters['endDate'] = requestParameters.endDate;
        }
        if (requestParameters.limit !== undefined) {
            queryParameters['limit'] = requestParameters.limit;
        }
        if (requestParameters.offset !== undefined) {
            queryParameters['offset'] = requestParameters.offset;
        }
        if (requestParameters.senders) {
            queryParameters['senders'] = requestParameters.senders.join(runtime.COLLECTION_FORMATS['csv']);
        }
        const headerParameters = {};
        if (this.configuration && this.configuration.apiKey) {
            headerParameters['api-key'] = await this.configuration.apiKey('api-key');
        }
        const response = await this.request({
            path: `/smtp/blockedContacts`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetTransacBlockedContactsFromJSON(jsonValue));
    }
    async getTransacBlockedContacts(requestParameters = {}, initOverrides) {
        const response = await this.getTransacBlockedContactsRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getTransacEmailContentRaw(requestParameters, initOverrides) {
        if (requestParameters.uuid === null || requestParameters.uuid === undefined) {
            throw new runtime.RequiredError('uuid', 'Required parameter requestParameters.uuid was null or undefined when calling getTransacEmailContent.');
        }
        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: `/smtp/emails/{uuid}`.replace(`{${'uuid'}}`, encodeURIComponent(String(requestParameters.uuid))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetTransacEmailContentFromJSON(jsonValue));
    }
    async getTransacEmailContent(requestParameters, initOverrides) {
        const response = await this.getTransacEmailContentRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async getTransacEmailsListRaw(requestParameters, initOverrides) {
        const queryParameters = {};
        if (requestParameters.email !== undefined) {
            queryParameters['email'] = requestParameters.email;
        }
        if (requestParameters.templateId !== undefined) {
            queryParameters['templateId'] = requestParameters.templateId;
        }
        if (requestParameters.messageId !== undefined) {
            queryParameters['messageId'] = requestParameters.messageId;
        }
        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: `/smtp/emails`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => GetTransacEmailsListFromJSON(jsonValue));
    }
    async getTransacEmailsList(requestParameters = {}, initOverrides) {
        const response = await this.getTransacEmailsListRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async sendTemplateRaw(requestParameters, initOverrides) {
        if (requestParameters.templateId === null || requestParameters.templateId === undefined) {
            throw new runtime.RequiredError('templateId', 'Required parameter requestParameters.templateId was null or undefined when calling sendTemplate.');
        }
        if (requestParameters.sendEmail === null || requestParameters.sendEmail === undefined) {
            throw new runtime.RequiredError('sendEmail', 'Required parameter requestParameters.sendEmail was null or undefined when calling sendTemplate.');
        }
        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: `/smtp/templates/{templateId}/send`.replace(`{${'templateId'}}`, encodeURIComponent(String(requestParameters.templateId))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SendEmailToJSON(requestParameters.sendEmail),
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => SendTemplateEmailFromJSON(jsonValue));
    }
    async sendTemplate(requestParameters, initOverrides) {
        const response = await this.sendTemplateRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async sendTestTemplateRaw(requestParameters, initOverrides) {
        if (requestParameters.templateId === null || requestParameters.templateId === undefined) {
            throw new runtime.RequiredError('templateId', 'Required parameter requestParameters.templateId was null or undefined when calling sendTestTemplate.');
        }
        if (requestParameters.sendTestEmail === null || requestParameters.sendTestEmail === undefined) {
            throw new runtime.RequiredError('sendTestEmail', 'Required parameter requestParameters.sendTestEmail was null or undefined when calling sendTestTemplate.');
        }
        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: `/smtp/templates/{templateId}/sendTest`.replace(`{${'templateId'}}`, encodeURIComponent(String(requestParameters.templateId))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SendTestEmailToJSON(requestParameters.sendTestEmail),
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async sendTestTemplate(requestParameters, initOverrides) {
        await this.sendTestTemplateRaw(requestParameters, initOverrides);
    }
    async sendTransacEmailRaw(requestParameters, initOverrides) {
        if (requestParameters.sendSmtpEmail === null || requestParameters.sendSmtpEmail === undefined) {
            throw new runtime.RequiredError('sendSmtpEmail', 'Required parameter requestParameters.sendSmtpEmail was null or undefined when calling sendTransacEmail.');
        }
        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: `/smtp/email`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SendSmtpEmailToJSON(requestParameters.sendSmtpEmail),
        }, initOverrides);
        return new runtime.JSONApiResponse(response, (jsonValue) => CreateSmtpEmailFromJSON(jsonValue));
    }
    async sendTransacEmail(requestParameters, initOverrides) {
        const response = await this.sendTransacEmailRaw(requestParameters, initOverrides);
        return await response.value();
    }
    async smtpBlockedContactsEmailDeleteRaw(requestParameters, initOverrides) {
        if (requestParameters.email === null || requestParameters.email === undefined) {
            throw new runtime.RequiredError('email', 'Required parameter requestParameters.email was null or undefined when calling smtpBlockedContactsEmailDelete.');
        }
        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: `/smtp/blockedContacts/{email}`.replace(`{${'email'}}`, encodeURIComponent(String(requestParameters.email))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async smtpBlockedContactsEmailDelete(requestParameters, initOverrides) {
        await this.smtpBlockedContactsEmailDeleteRaw(requestParameters, initOverrides);
    }
    async smtpLogMessageIdDeleteRaw(requestParameters, initOverrides) {
        if (requestParameters.messageId === null || requestParameters.messageId === undefined) {
            throw new runtime.RequiredError('messageId', 'Required parameter requestParameters.messageId was null or undefined when calling smtpLogMessageIdDelete.');
        }
        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: `/smtp/log/{messageId}`.replace(`{${'messageId'}}`, encodeURIComponent(String(requestParameters.messageId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async smtpLogMessageIdDelete(requestParameters, initOverrides) {
        await this.smtpLogMessageIdDeleteRaw(requestParameters, initOverrides);
    }
    async updateSmtpTemplateRaw(requestParameters, initOverrides) {
        if (requestParameters.templateId === null || requestParameters.templateId === undefined) {
            throw new runtime.RequiredError('templateId', 'Required parameter requestParameters.templateId was null or undefined when calling updateSmtpTemplate.');
        }
        if (requestParameters.smtpTemplate === null || requestParameters.smtpTemplate === undefined) {
            throw new runtime.RequiredError('smtpTemplate', 'Required parameter requestParameters.smtpTemplate was null or undefined when calling updateSmtpTemplate.');
        }
        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: `/smtp/templates/{templateId}`.replace(`{${'templateId'}}`, encodeURIComponent(String(requestParameters.templateId))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UpdateSmtpTemplateToJSON(requestParameters.smtpTemplate),
        }, initOverrides);
        return new runtime.VoidApiResponse(response);
    }
    async updateSmtpTemplate(requestParameters, initOverrides) {
        await this.updateSmtpTemplateRaw(requestParameters, initOverrides);
    }
}
export var GetEmailEventReportEventEnum;
(function (GetEmailEventReportEventEnum) {
    GetEmailEventReportEventEnum["Bounces"] = "bounces";
    GetEmailEventReportEventEnum["HardBounces"] = "hardBounces";
    GetEmailEventReportEventEnum["SoftBounces"] = "softBounces";
    GetEmailEventReportEventEnum["Delivered"] = "delivered";
    GetEmailEventReportEventEnum["Spam"] = "spam";
    GetEmailEventReportEventEnum["Requests"] = "requests";
    GetEmailEventReportEventEnum["Opened"] = "opened";
    GetEmailEventReportEventEnum["Clicks"] = "clicks";
    GetEmailEventReportEventEnum["Invalid"] = "invalid";
    GetEmailEventReportEventEnum["Deferred"] = "deferred";
    GetEmailEventReportEventEnum["Blocked"] = "blocked";
    GetEmailEventReportEventEnum["Unsubscribed"] = "unsubscribed";
})(GetEmailEventReportEventEnum || (GetEmailEventReportEventEnum = {}));
//# sourceMappingURL=SMTPApi.js.map