mailslurp-client/src/generated/apis/ConnectorControllerApi.ts

Official client for MailSlurp Email and SMS API. Create email addresses and phone numbers in Javascript without a mail server. Send and receive real emails in applications or tests.

/* tslint:disable */
/* eslint-disable */
/**
 * MailSlurp API
 * MailSlurp is an API for sending and receiving emails and SMS from dynamically allocated email addresses and phone numbers. It\'s designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository
 *
 * The version of the OpenAPI document: 6.5.2
 * Contact: contact@mailslurp.dev
 *
 * 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 {
  ConnectorDto,
  ConnectorDtoFromJSON,
  ConnectorDtoToJSON,
  ConnectorEventDto,
  ConnectorEventDtoFromJSON,
  ConnectorEventDtoToJSON,
  ConnectorImapConnectionDto,
  ConnectorImapConnectionDtoFromJSON,
  ConnectorImapConnectionDtoToJSON,
  ConnectorImapConnectionTestResult,
  ConnectorImapConnectionTestResultFromJSON,
  ConnectorImapConnectionTestResultToJSON,
  ConnectorProviderSettingsDto,
  ConnectorProviderSettingsDtoFromJSON,
  ConnectorProviderSettingsDtoToJSON,
  ConnectorSmtpConnectionDto,
  ConnectorSmtpConnectionDtoFromJSON,
  ConnectorSmtpConnectionDtoToJSON,
  ConnectorSmtpConnectionTestResult,
  ConnectorSmtpConnectionTestResultFromJSON,
  ConnectorSmtpConnectionTestResultToJSON,
  ConnectorSyncRequestResult,
  ConnectorSyncRequestResultFromJSON,
  ConnectorSyncRequestResultToJSON,
  ConnectorSyncSettingsDto,
  ConnectorSyncSettingsDtoFromJSON,
  ConnectorSyncSettingsDtoToJSON,
  CreateConnectorImapConnectionOptions,
  CreateConnectorImapConnectionOptionsFromJSON,
  CreateConnectorImapConnectionOptionsToJSON,
  CreateConnectorOptions,
  CreateConnectorOptionsFromJSON,
  CreateConnectorOptionsToJSON,
  CreateConnectorSmtpConnectionOptions,
  CreateConnectorSmtpConnectionOptionsFromJSON,
  CreateConnectorSmtpConnectionOptionsToJSON,
  CreateConnectorSyncSettingsOptions,
  CreateConnectorSyncSettingsOptionsFromJSON,
  CreateConnectorSyncSettingsOptionsToJSON,
  CreateConnectorWithOptions,
  CreateConnectorWithOptionsFromJSON,
  CreateConnectorWithOptionsToJSON,
  OptionalConnectorDto,
  OptionalConnectorDtoFromJSON,
  OptionalConnectorDtoToJSON,
  OptionalConnectorImapConnectionDto,
  OptionalConnectorImapConnectionDtoFromJSON,
  OptionalConnectorImapConnectionDtoToJSON,
  OptionalConnectorSmtpConnectionDto,
  OptionalConnectorSmtpConnectionDtoFromJSON,
  OptionalConnectorSmtpConnectionDtoToJSON,
  OptionalConnectorSyncSettingsDto,
  OptionalConnectorSyncSettingsDtoFromJSON,
  OptionalConnectorSyncSettingsDtoToJSON,
  PageConnector,
  PageConnectorFromJSON,
  PageConnectorToJSON,
  PageConnectorEvents,
  PageConnectorEventsFromJSON,
  PageConnectorEventsToJSON,
  SendEmailOptions,
  SendEmailOptionsFromJSON,
  SendEmailOptionsToJSON,
  SentEmailDto,
  SentEmailDtoFromJSON,
  SentEmailDtoToJSON,
} from '../models';

export interface CreateConnectorRequest {
  createConnectorOptions: CreateConnectorOptions;
  inboxId?: string;
}

export interface CreateConnectorImapConnectionRequest {
  id: string;
  createConnectorImapConnectionOptions: CreateConnectorImapConnectionOptions;
}

export interface CreateConnectorSmtpConnectionRequest {
  id: string;
  createConnectorSmtpConnectionOptions: CreateConnectorSmtpConnectionOptions;
}

export interface CreateConnectorSyncSettingsRequest {
  id: string;
  createConnectorSyncSettingsOptions: CreateConnectorSyncSettingsOptions;
}

export interface CreateConnectorWithOptionsRequest {
  createConnectorWithOptions: CreateConnectorWithOptions;
  inboxId?: string;
}

export interface DeleteConnectorRequest {
  id: string;
}

export interface DeleteConnectorImapConnectionRequest {
  id: string;
}

export interface DeleteConnectorSmtpConnectionRequest {
  id: string;
}

export interface DeleteConnectorSyncSettingsRequest {
  id: string;
}

export interface GetAllConnectorEventsRequest {
  id?: string;
  page?: number;
  size?: number;
  sort?: GetAllConnectorEventsSortEnum;
  since?: Date;
  before?: Date;
  eventType?: GetAllConnectorEventsEventTypeEnum;
}

export interface GetConnectorRequest {
  id: string;
}

export interface GetConnectorByEmailAddressRequest {
  emailAddress: string;
}

export interface GetConnectorByInboxIdRequest {
  inboxId: string;
}

export interface GetConnectorByNameRequest {
  name: string;
}

export interface GetConnectorEventRequest {
  id: string;
}

export interface GetConnectorEventsRequest {
  id: string;
  page?: number;
  size?: number;
  sort?: GetConnectorEventsSortEnum;
  since?: Date;
  before?: Date;
  eventType?: GetConnectorEventsEventTypeEnum;
}

export interface GetConnectorImapConnectionRequest {
  id: string;
}

export interface GetConnectorSmtpConnectionRequest {
  id: string;
}

export interface GetConnectorSyncSettingsRequest {
  id: string;
}

export interface GetConnectorsRequest {
  page?: number;
  size?: number;
  sort?: GetConnectorsSortEnum;
  since?: Date;
  before?: Date;
}

export interface SendEmailFromConnectorRequest {
  id: string;
  sendEmailOptions: SendEmailOptions;
  useFallback?: boolean;
}

export interface SyncConnectorRequest {
  id: string;
  since?: Date;
  folder?: string;
  logging?: boolean;
}

export interface TestConnectorImapConnectionRequest {
  id: string;
  createConnectorImapConnectionOptions?: CreateConnectorImapConnectionOptions;
}

export interface TestConnectorImapConnectionOptionsRequest {
  createConnectorImapConnectionOptions: CreateConnectorImapConnectionOptions;
}

export interface TestConnectorSmtpConnectionRequest {
  id: string;
  createConnectorSmtpConnectionOptions?: CreateConnectorSmtpConnectionOptions;
}

export interface TestConnectorSmtpConnectionOptionsRequest {
  createConnectorSmtpConnectionOptions: CreateConnectorSmtpConnectionOptions;
}

export interface UpdateConnectorRequest {
  id: string;
  createConnectorOptions: CreateConnectorOptions;
}

export interface UpdateConnectorImapConnectionRequest {
  id: string;
  createConnectorImapConnectionOptions: CreateConnectorImapConnectionOptions;
}

export interface UpdateConnectorSmtpConnectionRequest {
  id: string;
  createConnectorSmtpConnectionOptions: CreateConnectorSmtpConnectionOptions;
}

/**
 *
 */
export class ConnectorControllerApi extends runtime.BaseAPI {
  /**
   * Sync emails between external mailboxes and MailSlurp inboxes
   * Create an inbox connector
   */
  async createConnectorRaw(
    requestParameters: CreateConnectorRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConnectorDto>> {
    if (
      requestParameters.createConnectorOptions === null ||
      requestParameters.createConnectorOptions === undefined
    ) {
      throw new runtime.RequiredError(
        'createConnectorOptions',
        'Required parameter requestParameters.createConnectorOptions was null or undefined when calling createConnector.'
      );
    }

    const queryParameters: any = {};

    if (requestParameters.inboxId !== undefined) {
      queryParameters['inboxId'] = requestParameters.inboxId;
    }

    const headerParameters: runtime.HTTPHeaders = {};

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

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: CreateConnectorOptionsToJSON(
          requestParameters.createConnectorOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Sync emails between external mailboxes and MailSlurp inboxes
   * Create an inbox connector
   */
  async createConnector(
    requestParameters: CreateConnectorRequest,
    initOverrides?: RequestInit
  ): Promise<ConnectorDto> {
    const response = await this.createConnectorRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Allows the reading of emails in an external mailbox and syncing to a MailSlurp inbox
   * Create an inbox connector IMAP connection
   */
  async createConnectorImapConnectionRaw(
    requestParameters: CreateConnectorImapConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConnectorImapConnectionDto>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling createConnectorImapConnection.'
      );
    }

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

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

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

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/imap`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: CreateConnectorImapConnectionOptionsToJSON(
          requestParameters.createConnectorImapConnectionOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Allows the reading of emails in an external mailbox and syncing to a MailSlurp inbox
   * Create an inbox connector IMAP connection
   */
  async createConnectorImapConnection(
    requestParameters: CreateConnectorImapConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<ConnectorImapConnectionDto> {
    const response = await this.createConnectorImapConnectionRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Allows sending via connector and email is routed to connected inbox and sent via SMTP
   * Create an inbox connector SMTP connection
   */
  async createConnectorSmtpConnectionRaw(
    requestParameters: CreateConnectorSmtpConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConnectorSmtpConnectionDto>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling createConnectorSmtpConnection.'
      );
    }

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

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

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

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/smtp`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: CreateConnectorSmtpConnectionOptionsToJSON(
          requestParameters.createConnectorSmtpConnectionOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Allows sending via connector and email is routed to connected inbox and sent via SMTP
   * Create an inbox connector SMTP connection
   */
  async createConnectorSmtpConnection(
    requestParameters: CreateConnectorSmtpConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<ConnectorSmtpConnectionDto> {
    const response = await this.createConnectorSmtpConnectionRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Configure automatic pull or emails from external inboxes using an interval or schedule
   * Create an inbox connector sync settings
   */
  async createConnectorSyncSettingsRaw(
    requestParameters: CreateConnectorSyncSettingsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConnectorSyncSettingsDto>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling createConnectorSyncSettings.'
      );
    }

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

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

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

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/sync-settings`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: CreateConnectorSyncSettingsOptionsToJSON(
          requestParameters.createConnectorSyncSettingsOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Configure automatic pull or emails from external inboxes using an interval or schedule
   * Create an inbox connector sync settings
   */
  async createConnectorSyncSettings(
    requestParameters: CreateConnectorSyncSettingsRequest,
    initOverrides?: RequestInit
  ): Promise<ConnectorSyncSettingsDto> {
    const response = await this.createConnectorSyncSettingsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Sync emails between external mailboxes and MailSlurp inboxes
   * Create an inbox connector with options
   */
  async createConnectorWithOptionsRaw(
    requestParameters: CreateConnectorWithOptionsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConnectorDto>> {
    if (
      requestParameters.createConnectorWithOptions === null ||
      requestParameters.createConnectorWithOptions === undefined
    ) {
      throw new runtime.RequiredError(
        'createConnectorWithOptions',
        'Required parameter requestParameters.createConnectorWithOptions was null or undefined when calling createConnectorWithOptions.'
      );
    }

    const queryParameters: any = {};

    if (requestParameters.inboxId !== undefined) {
      queryParameters['inboxId'] = requestParameters.inboxId;
    }

    const headerParameters: runtime.HTTPHeaders = {};

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

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/withOptions`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: CreateConnectorWithOptionsToJSON(
          requestParameters.createConnectorWithOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Sync emails between external mailboxes and MailSlurp inboxes
   * Create an inbox connector with options
   */
  async createConnectorWithOptions(
    requestParameters: CreateConnectorWithOptionsRequest,
    initOverrides?: RequestInit
  ): Promise<ConnectorDto> {
    const response = await this.createConnectorWithOptionsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Delete all inbox connectors
   */
  async deleteAllConnectorRaw(
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors`,
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Delete all inbox connectors
   */
  async deleteAllConnector(initOverrides?: RequestInit): Promise<void> {
    await this.deleteAllConnectorRaw(initOverrides);
  }

  /**
   * Delete an inbox connector
   */
  async deleteConnectorRaw(
    requestParameters: DeleteConnectorRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling deleteConnector.'
      );
    }

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Delete an inbox connector
   */
  async deleteConnector(
    requestParameters: DeleteConnectorRequest,
    initOverrides?: RequestInit
  ): Promise<void> {
    await this.deleteConnectorRaw(requestParameters, initOverrides);
  }

  /**
   * Delete IMAP connection for external inbox
   * Delete an inbox connector IMAP connection
   */
  async deleteConnectorImapConnectionRaw(
    requestParameters: DeleteConnectorImapConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling deleteConnectorImapConnection.'
      );
    }

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/imap`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Delete IMAP connection for external inbox
   * Delete an inbox connector IMAP connection
   */
  async deleteConnectorImapConnection(
    requestParameters: DeleteConnectorImapConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<void> {
    await this.deleteConnectorImapConnectionRaw(
      requestParameters,
      initOverrides
    );
  }

  /**
   * Delete SMTP connection for external inbox
   * Delete an inbox connector SMTP connection
   */
  async deleteConnectorSmtpConnectionRaw(
    requestParameters: DeleteConnectorSmtpConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling deleteConnectorSmtpConnection.'
      );
    }

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/smtp`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Delete SMTP connection for external inbox
   * Delete an inbox connector SMTP connection
   */
  async deleteConnectorSmtpConnection(
    requestParameters: DeleteConnectorSmtpConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<void> {
    await this.deleteConnectorSmtpConnectionRaw(
      requestParameters,
      initOverrides
    );
  }

  /**
   * Configure automatic pull or emails from external inboxes using an interval or schedule
   * Create an inbox connector sync settings
   */
  async deleteConnectorSyncSettingsRaw(
    requestParameters: DeleteConnectorSyncSettingsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling deleteConnectorSyncSettings.'
      );
    }

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/sync-settings`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Configure automatic pull or emails from external inboxes using an interval or schedule
   * Create an inbox connector sync settings
   */
  async deleteConnectorSyncSettings(
    requestParameters: DeleteConnectorSyncSettingsRequest,
    initOverrides?: RequestInit
  ): Promise<void> {
    await this.deleteConnectorSyncSettingsRaw(requestParameters, initOverrides);
  }

  /**
   * Get all inbox connector events
   */
  async getAllConnectorEventsRaw(
    requestParameters: GetAllConnectorEventsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PageConnectorEvents>> {
    const queryParameters: any = {};

    if (requestParameters.id !== undefined) {
      queryParameters['id'] = requestParameters.id;
    }

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

    if (requestParameters.size !== undefined) {
      queryParameters['size'] = requestParameters.size;
    }

    if (requestParameters.sort !== undefined) {
      queryParameters['sort'] = requestParameters.sort;
    }

    if (requestParameters.since !== undefined) {
      queryParameters['since'] = (requestParameters.since as any).toISOString();
    }

    if (requestParameters.before !== undefined) {
      queryParameters['before'] = (
        requestParameters.before as any
      ).toISOString();
    }

    if (requestParameters.eventType !== undefined) {
      queryParameters['eventType'] = requestParameters.eventType;
    }

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/events`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get all inbox connector events
   */
  async getAllConnectorEvents(
    requestParameters: GetAllConnectorEventsRequest,
    initOverrides?: RequestInit
  ): Promise<PageConnectorEvents> {
    const response = await this.getAllConnectorEventsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get an inbox connector
   */
  async getConnectorRaw(
    requestParameters: GetConnectorRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConnectorDto>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling getConnector.'
      );
    }

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get an inbox connector
   */
  async getConnector(
    requestParameters: GetConnectorRequest,
    initOverrides?: RequestInit
  ): Promise<ConnectorDto> {
    const response = await this.getConnectorRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Find an inbox connector by email address
   * Get connector by email address
   */
  async getConnectorByEmailAddressRaw(
    requestParameters: GetConnectorByEmailAddressRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<OptionalConnectorDto>> {
    if (
      requestParameters.emailAddress === null ||
      requestParameters.emailAddress === undefined
    ) {
      throw new runtime.RequiredError(
        'emailAddress',
        'Required parameter requestParameters.emailAddress was null or undefined when calling getConnectorByEmailAddress.'
      );
    }

    const queryParameters: any = {};

    if (requestParameters.emailAddress !== undefined) {
      queryParameters['emailAddress'] = requestParameters.emailAddress;
    }

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/by-email-address`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Find an inbox connector by email address
   * Get connector by email address
   */
  async getConnectorByEmailAddress(
    requestParameters: GetConnectorByEmailAddressRequest,
    initOverrides?: RequestInit
  ): Promise<OptionalConnectorDto> {
    const response = await this.getConnectorByEmailAddressRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Find an inbox connector by inbox ID
   * Get connector by inbox ID
   */
  async getConnectorByInboxIdRaw(
    requestParameters: GetConnectorByInboxIdRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<OptionalConnectorDto>> {
    if (
      requestParameters.inboxId === null ||
      requestParameters.inboxId === undefined
    ) {
      throw new runtime.RequiredError(
        'inboxId',
        'Required parameter requestParameters.inboxId was null or undefined when calling getConnectorByInboxId.'
      );
    }

    const queryParameters: any = {};

    if (requestParameters.inboxId !== undefined) {
      queryParameters['inboxId'] = requestParameters.inboxId;
    }

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/by-inbox-id`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Find an inbox connector by inbox ID
   * Get connector by inbox ID
   */
  async getConnectorByInboxId(
    requestParameters: GetConnectorByInboxIdRequest,
    initOverrides?: RequestInit
  ): Promise<OptionalConnectorDto> {
    const response = await this.getConnectorByInboxIdRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Find an inbox connector by name
   * Get connector by name
   */
  async getConnectorByNameRaw(
    requestParameters: GetConnectorByNameRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<OptionalConnectorDto>> {
    if (
      requestParameters.name === null ||
      requestParameters.name === undefined
    ) {
      throw new runtime.RequiredError(
        'name',
        'Required parameter requestParameters.name was null or undefined when calling getConnectorByName.'
      );
    }

    const queryParameters: any = {};

    if (requestParameters.name !== undefined) {
      queryParameters['name'] = requestParameters.name;
    }

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/by-name`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Find an inbox connector by name
   * Get connector by name
   */
  async getConnectorByName(
    requestParameters: GetConnectorByNameRequest,
    initOverrides?: RequestInit
  ): Promise<OptionalConnectorDto> {
    const response = await this.getConnectorByNameRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get an inbox connector event
   */
  async getConnectorEventRaw(
    requestParameters: GetConnectorEventRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConnectorEventDto>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling getConnectorEvent.'
      );
    }

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/events/{id}`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get an inbox connector event
   */
  async getConnectorEvent(
    requestParameters: GetConnectorEventRequest,
    initOverrides?: RequestInit
  ): Promise<ConnectorEventDto> {
    const response = await this.getConnectorEventRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get an inbox connector events
   */
  async getConnectorEventsRaw(
    requestParameters: GetConnectorEventsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PageConnectorEvents>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling getConnectorEvents.'
      );
    }

    const queryParameters: any = {};

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

    if (requestParameters.size !== undefined) {
      queryParameters['size'] = requestParameters.size;
    }

    if (requestParameters.sort !== undefined) {
      queryParameters['sort'] = requestParameters.sort;
    }

    if (requestParameters.since !== undefined) {
      queryParameters['since'] = (requestParameters.since as any).toISOString();
    }

    if (requestParameters.before !== undefined) {
      queryParameters['before'] = (
        requestParameters.before as any
      ).toISOString();
    }

    if (requestParameters.eventType !== undefined) {
      queryParameters['eventType'] = requestParameters.eventType;
    }

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/events`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get an inbox connector events
   */
  async getConnectorEvents(
    requestParameters: GetConnectorEventsRequest,
    initOverrides?: RequestInit
  ): Promise<PageConnectorEvents> {
    const response = await this.getConnectorEventsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get IMAP connection for external inbox
   * Get an inbox connector IMAP connection
   */
  async getConnectorImapConnectionRaw(
    requestParameters: GetConnectorImapConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<OptionalConnectorImapConnectionDto>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling getConnectorImapConnection.'
      );
    }

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/imap`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get IMAP connection for external inbox
   * Get an inbox connector IMAP connection
   */
  async getConnectorImapConnection(
    requestParameters: GetConnectorImapConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<OptionalConnectorImapConnectionDto> {
    const response = await this.getConnectorImapConnectionRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get common mail provider SMTP and IMAP connection settings
   * Get SMTP and IMAP connection settings for common mail providers
   */
  async getConnectorProviderSettingsRaw(
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConnectorProviderSettingsDto>> {
    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/provider-settings`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get common mail provider SMTP and IMAP connection settings
   * Get SMTP and IMAP connection settings for common mail providers
   */
  async getConnectorProviderSettings(
    initOverrides?: RequestInit
  ): Promise<ConnectorProviderSettingsDto> {
    const response = await this.getConnectorProviderSettingsRaw(initOverrides);
    return await response.value();
  }

  /**
   * Get SMTP connection for external inbox
   * Get an inbox connector SMTP connection
   */
  async getConnectorSmtpConnectionRaw(
    requestParameters: GetConnectorSmtpConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<OptionalConnectorSmtpConnectionDto>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling getConnectorSmtpConnection.'
      );
    }

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/smtp`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get SMTP connection for external inbox
   * Get an inbox connector SMTP connection
   */
  async getConnectorSmtpConnection(
    requestParameters: GetConnectorSmtpConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<OptionalConnectorSmtpConnectionDto> {
    const response = await this.getConnectorSmtpConnectionRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get sync settings for connection with external inbox
   * Get an inbox connector sync settings
   */
  async getConnectorSyncSettingsRaw(
    requestParameters: GetConnectorSyncSettingsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<OptionalConnectorSyncSettingsDto>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling getConnectorSyncSettings.'
      );
    }

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/sync-settings`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get sync settings for connection with external inbox
   * Get an inbox connector sync settings
   */
  async getConnectorSyncSettings(
    requestParameters: GetConnectorSyncSettingsRequest,
    initOverrides?: RequestInit
  ): Promise<OptionalConnectorSyncSettingsDto> {
    const response = await this.getConnectorSyncSettingsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * List inbox connectors that sync external emails to MailSlurp inboxes
   * Get inbox connectors
   */
  async getConnectorsRaw(
    requestParameters: GetConnectorsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PageConnector>> {
    const queryParameters: any = {};

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

    if (requestParameters.size !== undefined) {
      queryParameters['size'] = requestParameters.size;
    }

    if (requestParameters.sort !== undefined) {
      queryParameters['sort'] = requestParameters.sort;
    }

    if (requestParameters.since !== undefined) {
      queryParameters['since'] = (requestParameters.since as any).toISOString();
    }

    if (requestParameters.before !== undefined) {
      queryParameters['before'] = (
        requestParameters.before as any
      ).toISOString();
    }

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List inbox connectors that sync external emails to MailSlurp inboxes
   * Get inbox connectors
   */
  async getConnectors(
    requestParameters: GetConnectorsRequest,
    initOverrides?: RequestInit
  ): Promise<PageConnector> {
    const response = await this.getConnectorsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Send from an inbox connector
   */
  async sendEmailFromConnectorRaw(
    requestParameters: SendEmailFromConnectorRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<SentEmailDto>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling sendEmailFromConnector.'
      );
    }

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

    const queryParameters: any = {};

    if (requestParameters.useFallback !== undefined) {
      queryParameters['useFallback'] = requestParameters.useFallback;
    }

    const headerParameters: runtime.HTTPHeaders = {};

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

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/send`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: SendEmailOptionsToJSON(requestParameters.sendEmailOptions),
      },
      initOverrides
    );

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

  /**
   * Send from an inbox connector
   */
  async sendEmailFromConnector(
    requestParameters: SendEmailFromConnectorRequest,
    initOverrides?: RequestInit
  ): Promise<SentEmailDto> {
    const response = await this.sendEmailFromConnectorRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Sync an inbox connector
   */
  async syncConnectorRaw(
    requestParameters: SyncConnectorRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConnectorSyncRequestResult>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling syncConnector.'
      );
    }

    const queryParameters: any = {};

    if (requestParameters.since !== undefined) {
      queryParameters['since'] = (requestParameters.since as any).toISOString();
    }

    if (requestParameters.folder !== undefined) {
      queryParameters['folder'] = requestParameters.folder;
    }

    if (requestParameters.logging !== undefined) {
      queryParameters['logging'] = requestParameters.logging;
    }

    const headerParameters: runtime.HTTPHeaders = {};

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/sync`.replace(
          `{${'id'}}`,
          encodeURIComponent(String(requestParameters.id))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Sync an inbox connector
   */
  async syncConnector(
    requestParameters: SyncConnectorRequest,
    initOverrides?: RequestInit
  ): Promise<ConnectorSyncRequestResult> {
    const response = await this.syncConnectorRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Test the IMAP connection for a connector
   * Test an inbox connector IMAP connection
   */
  async testConnectorImapConnectionRaw(
    requestParameters: TestConnectorImapConnectionRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConnectorImapConnectionTestResult>> {
    if (requestParameters.id === null || requestParameters.id === undefined) {
      throw new runtime.RequiredError(
        'id',
        'Required parameter requestParameters.id was null or undefined when calling testConnectorImapConnection.'
      );
    }

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

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

    if (this.configuration && this.configuration.apiKey) {
      headerParameters['x-api-key'] = this.configuration.apiKey('x-api-key'); // API_KEY authentication
    }

    const response = await this.request(
      {
        path: `/connectors/{id}/imap/test`.replace(
          `{$