/* 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 {
  CheckEmailAuthStackResults,
  CheckEmailAuthStackResultsFromJSON,
  CheckEmailAuthStackResultsToJSON,
  CreateDomainMonitorAlertSinkOptions,
  CreateDomainMonitorAlertSinkOptionsFromJSON,
  CreateDomainMonitorAlertSinkOptionsToJSON,
  CreateDomainMonitorOptions,
  CreateDomainMonitorOptionsFromJSON,
  CreateDomainMonitorOptionsToJSON,
  DomainMonitorAlertSinkDto,
  DomainMonitorAlertSinkDtoFromJSON,
  DomainMonitorAlertSinkDtoToJSON,
  DomainMonitorDto,
  DomainMonitorDtoFromJSON,
  DomainMonitorDtoToJSON,
  DomainMonitorInsightsDto,
  DomainMonitorInsightsDtoFromJSON,
  DomainMonitorInsightsDtoToJSON,
  DomainMonitorRunComparisonDto,
  DomainMonitorRunComparisonDtoFromJSON,
  DomainMonitorRunComparisonDtoToJSON,
  DomainMonitorRunDto,
  DomainMonitorRunDtoFromJSON,
  DomainMonitorRunDtoToJSON,
  DomainMonitorRunDueResult,
  DomainMonitorRunDueResultFromJSON,
  DomainMonitorRunDueResultToJSON,
  DomainMonitorRunNowResult,
  DomainMonitorRunNowResultFromJSON,
  DomainMonitorRunNowResultToJSON,
  DomainMonitorSeriesDto,
  DomainMonitorSeriesDtoFromJSON,
  DomainMonitorSeriesDtoToJSON,
  DomainMonitorSummaryDto,
  DomainMonitorSummaryDtoFromJSON,
  DomainMonitorSummaryDtoToJSON,
  UpdateDomainMonitorOptions,
  UpdateDomainMonitorOptionsFromJSON,
  UpdateDomainMonitorOptionsToJSON,
} from '../models';

export interface CompareDomainMonitorRunsRequest {
  monitorId: string;
  runId: string;
  otherRunId: string;
}

export interface CreateDomainMonitorRequest {
  createDomainMonitorOptions: CreateDomainMonitorOptions;
}

export interface CreateDomainMonitorAlertSinkRequest {
  monitorId: string;
  createDomainMonitorAlertSinkOptions: CreateDomainMonitorAlertSinkOptions;
}

export interface DeleteDomainMonitorRequest {
  monitorId: string;
}

export interface DeleteDomainMonitorAlertSinkRequest {
  monitorId: string;
  sinkId: string;
}

export interface GetDomainMonitorRequest {
  monitorId: string;
}

export interface GetDomainMonitorAlertSinksRequest {
  monitorId: string;
}

export interface GetDomainMonitorAuthStackRequest {
  monitorId: string;
  dkimSelector?: string;
}

export interface GetDomainMonitorInsightsRequest {
  monitorId: string;
  since?: Date;
  before?: Date;
}

export interface GetDomainMonitorRunRequest {
  monitorId: string;
  runId: string;
}

export interface GetDomainMonitorRunsRequest {
  monitorId: string;
  since?: Date;
  before?: Date;
  status?: GetDomainMonitorRunsStatusEnum;
  limit?: number;
}

export interface GetDomainMonitorSeriesRequest {
  monitorId: string;
  since?: Date;
  before?: Date;
  bucket?: GetDomainMonitorSeriesBucketEnum;
}

export interface GetDomainMonitorSummaryRequest {
  monitorId: string;
  dkimSelector?: string;
}

export interface RunDomainMonitorNowRequest {
  monitorId: string;
}

export interface RunDueDomainMonitorsRequest {
  maxRuns?: number;
}

export interface UpdateDomainMonitorRequest {
  monitorId: string;
  updateDomainMonitorOptions: UpdateDomainMonitorOptions;
}

/**
 *
 */
export class DomainMonitorControllerApi extends runtime.BaseAPI {
  /**
   * Compare two monitor runs
   */
  async compareDomainMonitorRunsRaw(
    requestParameters: CompareDomainMonitorRunsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<DomainMonitorRunComparisonDto>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling compareDomainMonitorRuns.'
      );
    }

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

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

    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: `/domain-monitor/monitors/{monitorId}/runs/{runId}/compare/{otherRunId}`
          .replace(
            `{${'monitorId'}}`,
            encodeURIComponent(String(requestParameters.monitorId))
          )
          .replace(
            `{${'runId'}}`,
            encodeURIComponent(String(requestParameters.runId))
          )
          .replace(
            `{${'otherRunId'}}`,
            encodeURIComponent(String(requestParameters.otherRunId))
          ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Compare two monitor runs
   */
  async compareDomainMonitorRuns(
    requestParameters: CompareDomainMonitorRunsRequest,
    initOverrides?: RequestInit
  ): Promise<DomainMonitorRunComparisonDto> {
    const response = await this.compareDomainMonitorRunsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Create domain monitor
   */
  async createDomainMonitorRaw(
    requestParameters: CreateDomainMonitorRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<DomainMonitorDto>> {
    if (
      requestParameters.createDomainMonitorOptions === null ||
      requestParameters.createDomainMonitorOptions === undefined
    ) {
      throw new runtime.RequiredError(
        'createDomainMonitorOptions',
        'Required parameter requestParameters.createDomainMonitorOptions was null or undefined when calling createDomainMonitor.'
      );
    }

    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: `/domain-monitor/monitors`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: CreateDomainMonitorOptionsToJSON(
          requestParameters.createDomainMonitorOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Create domain monitor
   */
  async createDomainMonitor(
    requestParameters: CreateDomainMonitorRequest,
    initOverrides?: RequestInit
  ): Promise<DomainMonitorDto> {
    const response = await this.createDomainMonitorRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Create alert sink for monitor
   */
  async createDomainMonitorAlertSinkRaw(
    requestParameters: CreateDomainMonitorAlertSinkRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<DomainMonitorAlertSinkDto>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling createDomainMonitorAlertSink.'
      );
    }

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

    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: `/domain-monitor/monitors/{monitorId}/alert-sinks`.replace(
          `{${'monitorId'}}`,
          encodeURIComponent(String(requestParameters.monitorId))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: CreateDomainMonitorAlertSinkOptionsToJSON(
          requestParameters.createDomainMonitorAlertSinkOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Create alert sink for monitor
   */
  async createDomainMonitorAlertSink(
    requestParameters: CreateDomainMonitorAlertSinkRequest,
    initOverrides?: RequestInit
  ): Promise<DomainMonitorAlertSinkDto> {
    const response = await this.createDomainMonitorAlertSinkRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Delete domain monitor
   */
  async deleteDomainMonitorRaw(
    requestParameters: DeleteDomainMonitorRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling deleteDomainMonitor.'
      );
    }

    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: `/domain-monitor/monitors/{monitorId}`.replace(
          `{${'monitorId'}}`,
          encodeURIComponent(String(requestParameters.monitorId))
        ),
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Delete domain monitor
   */
  async deleteDomainMonitor(
    requestParameters: DeleteDomainMonitorRequest,
    initOverrides?: RequestInit
  ): Promise<void> {
    await this.deleteDomainMonitorRaw(requestParameters, initOverrides);
  }

  /**
   * Delete monitor alert sink
   */
  async deleteDomainMonitorAlertSinkRaw(
    requestParameters: DeleteDomainMonitorAlertSinkRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling deleteDomainMonitorAlertSink.'
      );
    }

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

    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: `/domain-monitor/monitors/{monitorId}/alert-sinks/{sinkId}`
          .replace(
            `{${'monitorId'}}`,
            encodeURIComponent(String(requestParameters.monitorId))
          )
          .replace(
            `{${'sinkId'}}`,
            encodeURIComponent(String(requestParameters.sinkId))
          ),
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Delete monitor alert sink
   */
  async deleteDomainMonitorAlertSink(
    requestParameters: DeleteDomainMonitorAlertSinkRequest,
    initOverrides?: RequestInit
  ): Promise<void> {
    await this.deleteDomainMonitorAlertSinkRaw(
      requestParameters,
      initOverrides
    );
  }

  /**
   * Get domain monitor
   */
  async getDomainMonitorRaw(
    requestParameters: GetDomainMonitorRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<DomainMonitorDto>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling getDomainMonitor.'
      );
    }

    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: `/domain-monitor/monitors/{monitorId}`.replace(
          `{${'monitorId'}}`,
          encodeURIComponent(String(requestParameters.monitorId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get domain monitor
   */
  async getDomainMonitor(
    requestParameters: GetDomainMonitorRequest,
    initOverrides?: RequestInit
  ): Promise<DomainMonitorDto> {
    const response = await this.getDomainMonitorRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * List alert sinks for monitor
   */
  async getDomainMonitorAlertSinksRaw(
    requestParameters: GetDomainMonitorAlertSinksRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<Array<DomainMonitorAlertSinkDto>>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling getDomainMonitorAlertSinks.'
      );
    }

    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: `/domain-monitor/monitors/{monitorId}/alert-sinks`.replace(
          `{${'monitorId'}}`,
          encodeURIComponent(String(requestParameters.monitorId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List alert sinks for monitor
   */
  async getDomainMonitorAlertSinks(
    requestParameters: GetDomainMonitorAlertSinksRequest,
    initOverrides?: RequestInit
  ): Promise<Array<DomainMonitorAlertSinkDto>> {
    const response = await this.getDomainMonitorAlertSinksRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get current auth stack for monitor domain
   */
  async getDomainMonitorAuthStackRaw(
    requestParameters: GetDomainMonitorAuthStackRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<CheckEmailAuthStackResults>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling getDomainMonitorAuthStack.'
      );
    }

    const queryParameters: any = {};

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

    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: `/domain-monitor/monitors/{monitorId}/auth-stack`.replace(
          `{${'monitorId'}}`,
          encodeURIComponent(String(requestParameters.monitorId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get current auth stack for monitor domain
   */
  async getDomainMonitorAuthStack(
    requestParameters: GetDomainMonitorAuthStackRequest,
    initOverrides?: RequestInit
  ): Promise<CheckEmailAuthStackResults> {
    const response = await this.getDomainMonitorAuthStackRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get monitor insights
   */
  async getDomainMonitorInsightsRaw(
    requestParameters: GetDomainMonitorInsightsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<DomainMonitorInsightsDto>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling getDomainMonitorInsights.'
      );
    }

    const queryParameters: any = {};

    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: `/domain-monitor/monitors/{monitorId}/insights`.replace(
          `{${'monitorId'}}`,
          encodeURIComponent(String(requestParameters.monitorId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get monitor insights
   */
  async getDomainMonitorInsights(
    requestParameters: GetDomainMonitorInsightsRequest,
    initOverrides?: RequestInit
  ): Promise<DomainMonitorInsightsDto> {
    const response = await this.getDomainMonitorInsightsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get monitor run
   */
  async getDomainMonitorRunRaw(
    requestParameters: GetDomainMonitorRunRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<DomainMonitorRunDto>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling getDomainMonitorRun.'
      );
    }

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

    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: `/domain-monitor/monitors/{monitorId}/runs/{runId}`
          .replace(
            `{${'monitorId'}}`,
            encodeURIComponent(String(requestParameters.monitorId))
          )
          .replace(
            `{${'runId'}}`,
            encodeURIComponent(String(requestParameters.runId))
          ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get monitor run
   */
  async getDomainMonitorRun(
    requestParameters: GetDomainMonitorRunRequest,
    initOverrides?: RequestInit
  ): Promise<DomainMonitorRunDto> {
    const response = await this.getDomainMonitorRunRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * List monitor runs
   */
  async getDomainMonitorRunsRaw(
    requestParameters: GetDomainMonitorRunsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<Array<DomainMonitorRunDto>>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling getDomainMonitorRuns.'
      );
    }

    const queryParameters: any = {};

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

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

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

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

    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: `/domain-monitor/monitors/{monitorId}/runs`.replace(
          `{${'monitorId'}}`,
          encodeURIComponent(String(requestParameters.monitorId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List monitor runs
   */
  async getDomainMonitorRuns(
    requestParameters: GetDomainMonitorRunsRequest,
    initOverrides?: RequestInit
  ): Promise<Array<DomainMonitorRunDto>> {
    const response = await this.getDomainMonitorRunsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get monitor trend series
   */
  async getDomainMonitorSeriesRaw(
    requestParameters: GetDomainMonitorSeriesRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<DomainMonitorSeriesDto>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling getDomainMonitorSeries.'
      );
    }

    const queryParameters: any = {};

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

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

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

    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: `/domain-monitor/monitors/{monitorId}/series`.replace(
          `{${'monitorId'}}`,
          encodeURIComponent(String(requestParameters.monitorId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get monitor trend series
   */
  async getDomainMonitorSeries(
    requestParameters: GetDomainMonitorSeriesRequest,
    initOverrides?: RequestInit
  ): Promise<DomainMonitorSeriesDto> {
    const response = await this.getDomainMonitorSeriesRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get domain monitor summary
   */
  async getDomainMonitorSummaryRaw(
    requestParameters: GetDomainMonitorSummaryRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<DomainMonitorSummaryDto>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling getDomainMonitorSummary.'
      );
    }

    const queryParameters: any = {};

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

    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: `/domain-monitor/monitors/{monitorId}/summary`.replace(
          `{${'monitorId'}}`,
          encodeURIComponent(String(requestParameters.monitorId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get domain monitor summary
   */
  async getDomainMonitorSummary(
    requestParameters: GetDomainMonitorSummaryRequest,
    initOverrides?: RequestInit
  ): Promise<DomainMonitorSummaryDto> {
    const response = await this.getDomainMonitorSummaryRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * List domain monitors
   */
  async getDomainMonitorsRaw(
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<Array<DomainMonitorDto>>> {
    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: `/domain-monitor/monitors`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List domain monitors
   */
  async getDomainMonitors(
    initOverrides?: RequestInit
  ): Promise<Array<DomainMonitorDto>> {
    const response = await this.getDomainMonitorsRaw(initOverrides);
    return await response.value();
  }

  /**
   * Run monitor now
   */
  async runDomainMonitorNowRaw(
    requestParameters: RunDomainMonitorNowRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<DomainMonitorRunNowResult>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling runDomainMonitorNow.'
      );
    }

    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: `/domain-monitor/monitors/{monitorId}/run-now`.replace(
          `{${'monitorId'}}`,
          encodeURIComponent(String(requestParameters.monitorId))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Run monitor now
   */
  async runDomainMonitorNow(
    requestParameters: RunDomainMonitorNowRequest,
    initOverrides?: RequestInit
  ): Promise<DomainMonitorRunNowResult> {
    const response = await this.runDomainMonitorNowRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Run due monitors for user
   */
  async runDueDomainMonitorsRaw(
    requestParameters: RunDueDomainMonitorsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<DomainMonitorRunDueResult>> {
    const queryParameters: any = {};

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

    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: `/domain-monitor/monitors/run-due`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Run due monitors for user
   */
  async runDueDomainMonitors(
    requestParameters: RunDueDomainMonitorsRequest,
    initOverrides?: RequestInit
  ): Promise<DomainMonitorRunDueResult> {
    const response = await this.runDueDomainMonitorsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Update domain monitor
   */
  async updateDomainMonitorRaw(
    requestParameters: UpdateDomainMonitorRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<DomainMonitorDto>> {
    if (
      requestParameters.monitorId === null ||
      requestParameters.monitorId === undefined
    ) {
      throw new runtime.RequiredError(
        'monitorId',
        'Required parameter requestParameters.monitorId was null or undefined when calling updateDomainMonitor.'
      );
    }

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

    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: `/domain-monitor/monitors/{monitorId}`.replace(
          `{${'monitorId'}}`,
          encodeURIComponent(String(requestParameters.monitorId))
        ),
        method: 'PUT',
        headers: headerParameters,
        query: queryParameters,
        body: UpdateDomainMonitorOptionsToJSON(
          requestParameters.updateDomainMonitorOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Update domain monitor
   */
  async updateDomainMonitor(
    requestParameters: UpdateDomainMonitorRequest,
    initOverrides?: RequestInit
  ): Promise<DomainMonitorDto> {
    const response = await this.updateDomainMonitorRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }
}

/**
 * @export
 * @enum {string}
 */
export enum GetDomainMonitorRunsStatusEnum {
  HEALTHY = 'HEALTHY',
  DEGRADED = 'DEGRADED',
  CRITICAL = 'CRITICAL',
  FAILED = 'FAILED',
}
/**
 * @export
 * @enum {string}
 */
export enum GetDomainMonitorSeriesBucketEnum {
  HOUR = 'HOUR',
  DAY = 'DAY',
}