/* 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 {
  AcquirePhonePoolLeaseOptions,
  AcquirePhonePoolLeaseOptionsFromJSON,
  AcquirePhonePoolLeaseOptionsToJSON,
  AddPhonePoolNumbersOptions,
  AddPhonePoolNumbersOptionsFromJSON,
  AddPhonePoolNumbersOptionsToJSON,
  AvailablePhoneNumbersResult,
  AvailablePhoneNumbersResultFromJSON,
  AvailablePhoneNumbersResultToJSON,
  ConsentStatusDto,
  ConsentStatusDtoFromJSON,
  ConsentStatusDtoToJSON,
  CreateEmergencyAddressOptions,
  CreateEmergencyAddressOptionsFromJSON,
  CreateEmergencyAddressOptionsToJSON,
  CreatePhoneNumberOptions,
  CreatePhoneNumberOptionsFromJSON,
  CreatePhoneNumberOptionsToJSON,
  CreatePhonePoolOptions,
  CreatePhonePoolOptionsFromJSON,
  CreatePhonePoolOptionsToJSON,
  CreatePhoneProvisioningJobOptions,
  CreatePhoneProvisioningJobOptionsFromJSON,
  CreatePhoneProvisioningJobOptionsToJSON,
  EmergencyAddress,
  EmergencyAddressFromJSON,
  EmergencyAddressToJSON,
  EmergencyAddressDto,
  EmergencyAddressDtoFromJSON,
  EmergencyAddressDtoToJSON,
  EmptyResponseDto,
  EmptyResponseDtoFromJSON,
  EmptyResponseDtoToJSON,
  GetOrCreatePhonePoolOptions,
  GetOrCreatePhonePoolOptionsFromJSON,
  GetOrCreatePhonePoolOptionsToJSON,
  PagePhoneMessageThreadItemProjection,
  PagePhoneMessageThreadItemProjectionFromJSON,
  PagePhoneMessageThreadItemProjectionToJSON,
  PagePhoneMessageThreadProjection,
  PagePhoneMessageThreadProjectionFromJSON,
  PagePhoneMessageThreadProjectionToJSON,
  PagePhoneNumberProjection,
  PagePhoneNumberProjectionFromJSON,
  PagePhoneNumberProjectionToJSON,
  PagePhoneNumberReleaseProjection,
  PagePhoneNumberReleaseProjectionFromJSON,
  PagePhoneNumberReleaseProjectionToJSON,
  PageSentSmsProjection,
  PageSentSmsProjectionFromJSON,
  PageSentSmsProjectionToJSON,
  PageSmsProjection,
  PageSmsProjectionFromJSON,
  PageSmsProjectionToJSON,
  PhoneNumberDto,
  PhoneNumberDtoFromJSON,
  PhoneNumberDtoToJSON,
  PhoneNumberLineTypeLookupDto,
  PhoneNumberLineTypeLookupDtoFromJSON,
  PhoneNumberLineTypeLookupDtoToJSON,
  PhoneNumberReleaseProjection,
  PhoneNumberReleaseProjectionFromJSON,
  PhoneNumberReleaseProjectionToJSON,
  PhoneNumberTagsOptions,
  PhoneNumberTagsOptionsFromJSON,
  PhoneNumberTagsOptionsToJSON,
  PhoneNumberValidationDto,
  PhoneNumberValidationDtoFromJSON,
  PhoneNumberValidationDtoToJSON,
  PhonePlanAvailability,
  PhonePlanAvailabilityFromJSON,
  PhonePlanAvailabilityToJSON,
  PhonePlanDto,
  PhonePlanDtoFromJSON,
  PhonePlanDtoToJSON,
  PhonePoolDetailDto,
  PhonePoolDetailDtoFromJSON,
  PhonePoolDetailDtoToJSON,
  PhonePoolDto,
  PhonePoolDtoFromJSON,
  PhonePoolDtoToJSON,
  PhonePoolLeaseDto,
  PhonePoolLeaseDtoFromJSON,
  PhonePoolLeaseDtoToJSON,
  PhoneProviderCapabilitiesResult,
  PhoneProviderCapabilitiesResultFromJSON,
  PhoneProviderCapabilitiesResultToJSON,
  PhoneProvisioningJobDto,
  PhoneProvisioningJobDtoFromJSON,
  PhoneProvisioningJobDtoToJSON,
  PhoneSmsPrepaidCreditDto,
  PhoneSmsPrepaidCreditDtoFromJSON,
  PhoneSmsPrepaidCreditDtoToJSON,
  PhoneSmsPrepaidCreditsDto,
  PhoneSmsPrepaidCreditsDtoFromJSON,
  PhoneSmsPrepaidCreditsDtoToJSON,
  PhoneSummaryDto,
  PhoneSummaryDtoFromJSON,
  PhoneSummaryDtoToJSON,
  SearchAvailablePhoneNumbersOptions,
  SearchAvailablePhoneNumbersOptionsFromJSON,
  SearchAvailablePhoneNumbersOptionsToJSON,
  SentSmsDto,
  SentSmsDtoFromJSON,
  SentSmsDtoToJSON,
  SetPhoneFavouritedOptions,
  SetPhoneFavouritedOptionsFromJSON,
  SetPhoneFavouritedOptionsToJSON,
  SmsSendOptions,
  SmsSendOptionsFromJSON,
  SmsSendOptionsToJSON,
  TestPhoneNumberOptions,
  TestPhoneNumberOptionsFromJSON,
  TestPhoneNumberOptionsToJSON,
  UpdatePhoneNumberOptions,
  UpdatePhoneNumberOptionsFromJSON,
  UpdatePhoneNumberOptionsToJSON,
  UpdatePhonePoolOptions,
  UpdatePhonePoolOptionsFromJSON,
  UpdatePhonePoolOptionsToJSON,
  ValidatePhoneNumberOptions,
  ValidatePhoneNumberOptionsFromJSON,
  ValidatePhoneNumberOptionsToJSON,
} from '../models';

export interface AcquirePhonePoolLeaseRequest {
  poolId: string;
  acquirePhonePoolLeaseOptions: AcquirePhonePoolLeaseOptions;
}

export interface AddAllPhoneNumbersToPhonePoolRequest {
  poolId: string;
}

export interface AddPhoneNumberTagsRequest {
  phoneNumberId: string;
  phoneNumberTagsOptions: PhoneNumberTagsOptions;
}

export interface AddPhoneNumbersToPhonePoolRequest {
  poolId: string;
  addPhonePoolNumbersOptions: AddPhonePoolNumbersOptions;
}

export interface CreateEmergencyAddressRequest {
  createEmergencyAddressOptions: CreateEmergencyAddressOptions;
}

export interface CreatePhoneNumberRequest {
  createPhoneNumberOptions: CreatePhoneNumberOptions;
}

export interface CreatePhonePoolRequest {
  createPhonePoolOptions: CreatePhonePoolOptions;
}

export interface CreatePhoneProvisioningJobRequest {
  createPhoneProvisioningJobOptions: CreatePhoneProvisioningJobOptions;
}

export interface DeleteEmergencyAddressRequest {
  addressId: string;
}

export interface DeletePhoneMessageThreadItemsRequest {
  phoneNumberId: string;
  otherNumber: string;
}

export interface DeletePhoneNumberRequest {
  phoneNumberId: string;
}

export interface DeletePhonePoolRequest {
  poolId: string;
}

export interface GetAllPhoneMessageThreadsRequest {
  page?: number;
  size?: number;
}

export interface GetAllPhoneNumberReleasesRequest {
  page?: number;
  size?: number;
  sort?: GetAllPhoneNumberReleasesSortEnum;
}

export interface GetEmergencyAddressRequest {
  addressId: string;
}

export interface GetOrCreatePhonePoolRequest {
  getOrCreatePhonePoolOptions: GetOrCreatePhonePoolOptions;
}

export interface GetPhoneMessageThreadItemsRequest {
  phoneNumberId: string;
  otherNumber: string;
  page?: number;
  size?: number;
}

export interface GetPhoneMessageThreadsRequest {
  phoneNumberId: string;
  page?: number;
  size?: number;
}

export interface GetPhoneNumberRequest {
  phoneNumberId: string;
}

export interface GetPhoneNumberByNameRequest {
  name: string;
}

export interface GetPhoneNumberByPhoneNumberRequest {
  phoneNumber: string;
}

export interface GetPhoneNumberLineTypeIntelligenceRequest {
  validatePhoneNumberOptions: ValidatePhoneNumberOptions;
}

export interface GetPhoneNumberReleaseRequest {
  releaseId: string;
}

export interface GetPhoneNumberTagsRequest {
  phoneNumberId: string;
}

export interface GetPhoneNumbersRequest {
  phoneCountry?: GetPhoneNumbersPhoneCountryEnum;
  lineType?: string;
  carrierName?: string;
  mobileCountryCode?: string;
  mobileNetworkCode?: string;
  providerLabel?: string;
  page?: number;
  size?: number;
  sort?: GetPhoneNumbersSortEnum;
  since?: Date;
  before?: Date;
  search?: string;
  tag?: Array<string>;
  include?: Array<string>;
  favourite?: boolean;
}

export interface GetPhonePoolRequest {
  poolId: string;
}

export interface GetPhonePoolByNameRequest {
  name: string;
}

export interface GetPhoneProvisioningCapabilitiesRequest {
  phoneCountry: GetPhoneProvisioningCapabilitiesPhoneCountryEnum;
  providerLabel?: string;
}

export interface GetPhoneProvisioningJobRequest {
  jobId: string;
}

export interface GetPhoneSmsPrepaidCreditRequest {
  creditId: string;
}

export interface GetPhoneTagsRequest {
  search?: string;
}

export interface GetSentSmsByPhoneNumberRequest {
  phoneNumberId: string;
  page?: number;
  size?: number;
  sort?: GetSentSmsByPhoneNumberSortEnum;
  since?: Date;
  before?: Date;
  search?: string;
}

export interface GetSmsByPhoneNumberRequest {
  phoneNumberId: string;
  page?: number;
  size?: number;
  sort?: GetSmsByPhoneNumberSortEnum;
  unreadOnly?: boolean;
  since?: Date;
  before?: Date;
  search?: string;
  favourite?: boolean;
}

export interface ReassignPhoneNumberReleaseRequest {
  releaseId: string;
}

export interface ReleasePhonePoolLeaseRequest {
  poolId: string;
  leaseId: string;
}

export interface RemovePhoneNumberFromPhonePoolRequest {
  poolId: string;
  phoneNumberId: string;
}

export interface RemovePhoneNumberTagsRequest {
  phoneNumberId: string;
  phoneNumberTagsOptions: PhoneNumberTagsOptions;
}

export interface SearchAvailablePhoneNumbersRequest {
  searchAvailablePhoneNumbersOptions: SearchAvailablePhoneNumbersOptions;
}

export interface SendSmsFromPhoneNumberRequest {
  phoneNumberId: string;
  smsSendOptions: SmsSendOptions;
}

export interface SetConsentStatusRequest {
  agree: boolean;
}

export interface SetPhoneFavouritedRequest {
  phoneNumberId: string;
  setPhoneFavouritedOptions: SetPhoneFavouritedOptions;
}

export interface SetPhoneNumberTagsRequest {
  phoneNumberId: string;
  phoneNumberTagsOptions: PhoneNumberTagsOptions;
}

export interface TestPhoneNumberSendSmsRequest {
  phoneNumberId: string;
  testPhoneNumberOptions: TestPhoneNumberOptions;
  xTestId?: string;
}

export interface UpdatePhoneNumberRequest {
  phoneNumberId: string;
  updatePhoneNumberOptions: UpdatePhoneNumberOptions;
}

export interface UpdatePhonePoolRequest {
  poolId: string;
  updatePhonePoolOptions: UpdatePhonePoolOptions;
}

export interface ValidatePhoneNumberRequest {
  validatePhoneNumberOptions: ValidatePhoneNumberOptions;
}

/**
 *
 */
export class PhoneControllerApi extends runtime.BaseAPI {
  /**
   * Acquire an available phone number from the pool and mark it leased
   * Acquire phone pool lease
   */
  async acquirePhonePoolLeaseRaw(
    requestParameters: AcquirePhonePoolLeaseRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhonePoolLeaseDto>> {
    if (
      requestParameters.poolId === null ||
      requestParameters.poolId === undefined
    ) {
      throw new runtime.RequiredError(
        'poolId',
        'Required parameter requestParameters.poolId was null or undefined when calling acquirePhonePoolLease.'
      );
    }

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

    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: `/phone/pools/{poolId}/leases`.replace(
          `{${'poolId'}}`,
          encodeURIComponent(String(requestParameters.poolId))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: AcquirePhonePoolLeaseOptionsToJSON(
          requestParameters.acquirePhonePoolLeaseOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Acquire an available phone number from the pool and mark it leased
   * Acquire phone pool lease
   */
  async acquirePhonePoolLease(
    requestParameters: AcquirePhonePoolLeaseRequest,
    initOverrides?: RequestInit
  ): Promise<PhonePoolLeaseDto> {
    const response = await this.acquirePhonePoolLeaseRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Add all active owned phone numbers to a pool
   * Add all phone numbers to phone pool
   */
  async addAllPhoneNumbersToPhonePoolRaw(
    requestParameters: AddAllPhoneNumbersToPhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhonePoolDetailDto>> {
    if (
      requestParameters.poolId === null ||
      requestParameters.poolId === undefined
    ) {
      throw new runtime.RequiredError(
        'poolId',
        'Required parameter requestParameters.poolId was null or undefined when calling addAllPhoneNumbersToPhonePool.'
      );
    }

    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: `/phone/pools/{poolId}/numbers/add-all`.replace(
          `{${'poolId'}}`,
          encodeURIComponent(String(requestParameters.poolId))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Add all active owned phone numbers to a pool
   * Add all phone numbers to phone pool
   */
  async addAllPhoneNumbersToPhonePool(
    requestParameters: AddAllPhoneNumbersToPhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<PhonePoolDetailDto> {
    const response = await this.addAllPhoneNumbersToPhonePoolRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Add one or more tags to a phone number
   * Add phone number tags
   */
  async addPhoneNumberTagsRaw(
    requestParameters: AddPhoneNumberTagsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberDto>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling addPhoneNumberTags.'
      );
    }

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

    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: `/phone/numbers/{phoneNumberId}/tags`.replace(
          `{${'phoneNumberId'}}`,
          encodeURIComponent(String(requestParameters.phoneNumberId))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: PhoneNumberTagsOptionsToJSON(
          requestParameters.phoneNumberTagsOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Add one or more tags to a phone number
   * Add phone number tags
   */
  async addPhoneNumberTags(
    requestParameters: AddPhoneNumberTagsRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberDto> {
    const response = await this.addPhoneNumberTagsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Add one or more owned phone numbers to a pool
   * Add phone numbers to phone pool
   */
  async addPhoneNumbersToPhonePoolRaw(
    requestParameters: AddPhoneNumbersToPhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhonePoolDetailDto>> {
    if (
      requestParameters.poolId === null ||
      requestParameters.poolId === undefined
    ) {
      throw new runtime.RequiredError(
        'poolId',
        'Required parameter requestParameters.poolId was null or undefined when calling addPhoneNumbersToPhonePool.'
      );
    }

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

    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: `/phone/pools/{poolId}/numbers`.replace(
          `{${'poolId'}}`,
          encodeURIComponent(String(requestParameters.poolId))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: AddPhonePoolNumbersOptionsToJSON(
          requestParameters.addPhonePoolNumbersOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Add one or more owned phone numbers to a pool
   * Add phone numbers to phone pool
   */
  async addPhoneNumbersToPhonePool(
    requestParameters: AddPhoneNumbersToPhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<PhonePoolDetailDto> {
    const response = await this.addPhoneNumbersToPhonePoolRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Add an emergency address to a phone number
   * Create an emergency address
   */
  async createEmergencyAddressRaw(
    requestParameters: CreateEmergencyAddressRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<EmergencyAddress>> {
    if (
      requestParameters.createEmergencyAddressOptions === null ||
      requestParameters.createEmergencyAddressOptions === undefined
    ) {
      throw new runtime.RequiredError(
        'createEmergencyAddressOptions',
        'Required parameter requestParameters.createEmergencyAddressOptions was null or undefined when calling createEmergencyAddress.'
      );
    }

    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: `/phone/emergency-addresses`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: CreateEmergencyAddressOptionsToJSON(
          requestParameters.createEmergencyAddressOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Add an emergency address to a phone number
   * Create an emergency address
   */
  async createEmergencyAddress(
    requestParameters: CreateEmergencyAddressRequest,
    initOverrides?: RequestInit
  ): Promise<EmergencyAddress> {
    const response = await this.createEmergencyAddressRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Create new phone number
   * Add phone number to your account. Only works if you have already added a plan and an initial phone number in your account and acknowledged the pricing and terms of service by enabling API phone creation.
   */
  async createPhoneNumberRaw(
    requestParameters: CreatePhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberDto>> {
    if (
      requestParameters.createPhoneNumberOptions === null ||
      requestParameters.createPhoneNumberOptions === undefined
    ) {
      throw new runtime.RequiredError(
        'createPhoneNumberOptions',
        'Required parameter requestParameters.createPhoneNumberOptions was null or undefined when calling createPhoneNumber.'
      );
    }

    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: `/phone`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: CreatePhoneNumberOptionsToJSON(
          requestParameters.createPhoneNumberOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Create new phone number
   * Add phone number to your account. Only works if you have already added a plan and an initial phone number in your account and acknowledged the pricing and terms of service by enabling API phone creation.
   */
  async createPhoneNumber(
    requestParameters: CreatePhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberDto> {
    const response = await this.createPhoneNumberRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Create a reusable pool of phone numbers for coordinated leasing
   * Create phone pool
   */
  async createPhonePoolRaw(
    requestParameters: CreatePhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhonePoolDetailDto>> {
    if (
      requestParameters.createPhonePoolOptions === null ||
      requestParameters.createPhonePoolOptions === undefined
    ) {
      throw new runtime.RequiredError(
        'createPhonePoolOptions',
        'Required parameter requestParameters.createPhonePoolOptions was null or undefined when calling createPhonePool.'
      );
    }

    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: `/phone/pools`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: CreatePhonePoolOptionsToJSON(
          requestParameters.createPhonePoolOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Create a reusable pool of phone numbers for coordinated leasing
   * Create phone pool
   */
  async createPhonePool(
    requestParameters: CreatePhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<PhonePoolDetailDto> {
    const response = await this.createPhonePoolRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Create an advanced phone provisioning job from shortlisted numbers
   * Create a phone provisioning job
   */
  async createPhoneProvisioningJobRaw(
    requestParameters: CreatePhoneProvisioningJobRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneProvisioningJobDto>> {
    if (
      requestParameters.createPhoneProvisioningJobOptions === null ||
      requestParameters.createPhoneProvisioningJobOptions === undefined
    ) {
      throw new runtime.RequiredError(
        'createPhoneProvisioningJobOptions',
        'Required parameter requestParameters.createPhoneProvisioningJobOptions was null or undefined when calling createPhoneProvisioningJob.'
      );
    }

    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: `/phone/provisioning/jobs`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: CreatePhoneProvisioningJobOptionsToJSON(
          requestParameters.createPhoneProvisioningJobOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Create an advanced phone provisioning job from shortlisted numbers
   * Create a phone provisioning job
   */
  async createPhoneProvisioningJob(
    requestParameters: CreatePhoneProvisioningJobRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneProvisioningJobDto> {
    const response = await this.createPhoneProvisioningJobRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Remove all phone number from account
   * Delete all phone numbers
   */
  async deleteAllPhoneNumberRaw(
    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: `/phone/numbers`,
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Remove all phone number from account
   * Delete all phone numbers
   */
  async deleteAllPhoneNumber(initOverrides?: RequestInit): Promise<void> {
    await this.deleteAllPhoneNumberRaw(initOverrides);
  }

  /**
   * Delete an emergency address
   * Delete an emergency address
   */
  async deleteEmergencyAddressRaw(
    requestParameters: DeleteEmergencyAddressRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<EmptyResponseDto>> {
    if (
      requestParameters.addressId === null ||
      requestParameters.addressId === undefined
    ) {
      throw new runtime.RequiredError(
        'addressId',
        'Required parameter requestParameters.addressId was null or undefined when calling deleteEmergencyAddress.'
      );
    }

    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: `/phone/emergency-addresses/{addressId}`.replace(
          `{${'addressId'}}`,
          encodeURIComponent(String(requestParameters.addressId))
        ),
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Delete an emergency address
   * Delete an emergency address
   */
  async deleteEmergencyAddress(
    requestParameters: DeleteEmergencyAddressRequest,
    initOverrides?: RequestInit
  ): Promise<EmptyResponseDto> {
    const response = await this.deleteEmergencyAddressRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Delete all messages in an SMS thread
   * Delete messages in a phone thread
   */
  async deletePhoneMessageThreadItemsRaw(
    requestParameters: DeletePhoneMessageThreadItemsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<EmptyResponseDto>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling deletePhoneMessageThreadItems.'
      );
    }

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

    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: `/phone/numbers/{phoneNumberId}/message-threads/{otherNumber}`
          .replace(
            `{${'phoneNumberId'}}`,
            encodeURIComponent(String(requestParameters.phoneNumberId))
          )
          .replace(
            `{${'otherNumber'}}`,
            encodeURIComponent(String(requestParameters.otherNumber))
          ),
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Delete all messages in an SMS thread
   * Delete messages in a phone thread
   */
  async deletePhoneMessageThreadItems(
    requestParameters: DeletePhoneMessageThreadItemsRequest,
    initOverrides?: RequestInit
  ): Promise<EmptyResponseDto> {
    const response = await this.deletePhoneMessageThreadItemsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Remove phone number from account
   * Delete a phone number
   */
  async deletePhoneNumberRaw(
    requestParameters: DeletePhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling deletePhoneNumber.'
      );
    }

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

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Remove phone number from account
   * Delete a phone number
   */
  async deletePhoneNumber(
    requestParameters: DeletePhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<void> {
    await this.deletePhoneNumberRaw(requestParameters, initOverrides);
  }

  /**
   * Delete a phone pool and release any active leases from that pool
   * Delete phone pool
   */
  async deletePhonePoolRaw(
    requestParameters: DeletePhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    if (
      requestParameters.poolId === null ||
      requestParameters.poolId === undefined
    ) {
      throw new runtime.RequiredError(
        'poolId',
        'Required parameter requestParameters.poolId was null or undefined when calling deletePhonePool.'
      );
    }

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

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Delete a phone pool and release any active leases from that pool
   * Delete phone pool
   */
  async deletePhonePool(
    requestParameters: DeletePhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<void> {
    await this.deletePhonePoolRaw(requestParameters, initOverrides);
  }

  /**
   * List all message threads for all phones
   * Get the latest messages for all phones
   */
  async getAllPhoneMessageThreadsRaw(
    requestParameters: GetAllPhoneMessageThreadsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PagePhoneMessageThreadProjection>> {
    const queryParameters: any = {};

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

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

    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: `/phone/numbers/message-threads`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List all message threads for all phones
   * Get the latest messages for all phones
   */
  async getAllPhoneMessageThreads(
    requestParameters: GetAllPhoneMessageThreadsRequest,
    initOverrides?: RequestInit
  ): Promise<PagePhoneMessageThreadProjection> {
    const response = await this.getAllPhoneMessageThreadsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * List released or deleted phone numbers
   * Get all phone number releases
   */
  async getAllPhoneNumberReleasesRaw(
    requestParameters: GetAllPhoneNumberReleasesRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PagePhoneNumberReleaseProjection>> {
    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;
    }

    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: `/phone/releases`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List released or deleted phone numbers
   * Get all phone number releases
   */
  async getAllPhoneNumberReleases(
    requestParameters: GetAllPhoneNumberReleasesRequest,
    initOverrides?: RequestInit
  ): Promise<PagePhoneNumberReleaseProjection> {
    const response = await this.getAllPhoneNumberReleasesRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get the status of phone usage consent
   * Get consent status
   */
  async getConsentStatusRaw(
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConsentStatusDto>> {
    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: `/phone/consent`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get the status of phone usage consent
   * Get consent status
   */
  async getConsentStatus(
    initOverrides?: RequestInit
  ): Promise<ConsentStatusDto> {
    const response = await this.getConsentStatusRaw(initOverrides);
    return await response.value();
  }

  /**
   * Fetch an emergency address by ID
   * Get an emergency address
   */
  async getEmergencyAddressRaw(
    requestParameters: GetEmergencyAddressRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<EmergencyAddress>> {
    if (
      requestParameters.addressId === null ||
      requestParameters.addressId === undefined
    ) {
      throw new runtime.RequiredError(
        'addressId',
        'Required parameter requestParameters.addressId was null or undefined when calling getEmergencyAddress.'
      );
    }

    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: `/phone/emergency-addresses/{addressId}`.replace(
          `{${'addressId'}}`,
          encodeURIComponent(String(requestParameters.addressId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Fetch an emergency address by ID
   * Get an emergency address
   */
  async getEmergencyAddress(
    requestParameters: GetEmergencyAddressRequest,
    initOverrides?: RequestInit
  ): Promise<EmergencyAddress> {
    const response = await this.getEmergencyAddressRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * List emergency addresses
   * Get emergency addresses
   */
  async getEmergencyAddressesRaw(
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<Array<EmergencyAddressDto>>> {
    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: `/phone/emergency-addresses`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List emergency addresses
   * Get emergency addresses
   */
  async getEmergencyAddresses(
    initOverrides?: RequestInit
  ): Promise<Array<EmergencyAddressDto>> {
    const response = await this.getEmergencyAddressesRaw(initOverrides);
    return await response.value();
  }

  /**
   * Get a phone pool by name or create it if it does not exist
   * Get or create phone pool
   */
  async getOrCreatePhonePoolRaw(
    requestParameters: GetOrCreatePhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhonePoolDetailDto>> {
    if (
      requestParameters.getOrCreatePhonePoolOptions === null ||
      requestParameters.getOrCreatePhonePoolOptions === undefined
    ) {
      throw new runtime.RequiredError(
        'getOrCreatePhonePoolOptions',
        'Required parameter requestParameters.getOrCreatePhonePoolOptions was null or undefined when calling getOrCreatePhonePool.'
      );
    }

    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: `/phone/pools/get-or-create`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: GetOrCreatePhonePoolOptionsToJSON(
          requestParameters.getOrCreatePhonePoolOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Get a phone pool by name or create it if it does not exist
   * Get or create phone pool
   */
  async getOrCreatePhonePool(
    requestParameters: GetOrCreatePhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<PhonePoolDetailDto> {
    const response = await this.getOrCreatePhonePoolRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * List message thread messages for a phone message thread
   * Get messages in a phone thread
   */
  async getPhoneMessageThreadItemsRaw(
    requestParameters: GetPhoneMessageThreadItemsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PagePhoneMessageThreadItemProjection>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling getPhoneMessageThreadItems.'
      );
    }

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

    const queryParameters: any = {};

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

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

    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: `/phone/numbers/{phoneNumberId}/message-threads/{otherNumber}`
          .replace(
            `{${'phoneNumberId'}}`,
            encodeURIComponent(String(requestParameters.phoneNumberId))
          )
          .replace(
            `{${'otherNumber'}}`,
            encodeURIComponent(String(requestParameters.otherNumber))
          ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List message thread messages for a phone message thread
   * Get messages in a phone thread
   */
  async getPhoneMessageThreadItems(
    requestParameters: GetPhoneMessageThreadItemsRequest,
    initOverrides?: RequestInit
  ): Promise<PagePhoneMessageThreadItemProjection> {
    const response = await this.getPhoneMessageThreadItemsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * List message threads for a phone
   * Get the latest message preview for a thread
   */
  async getPhoneMessageThreadsRaw(
    requestParameters: GetPhoneMessageThreadsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PagePhoneMessageThreadProjection>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling getPhoneMessageThreads.'
      );
    }

    const queryParameters: any = {};

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

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

    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: `/phone/numbers/{phoneNumberId}/message-threads`.replace(
          `{${'phoneNumberId'}}`,
          encodeURIComponent(String(requestParameters.phoneNumberId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List message threads for a phone
   * Get the latest message preview for a thread
   */
  async getPhoneMessageThreads(
    requestParameters: GetPhoneMessageThreadsRequest,
    initOverrides?: RequestInit
  ): Promise<PagePhoneMessageThreadProjection> {
    const response = await this.getPhoneMessageThreadsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get a phone number by ID
   * Get a phone number by ID
   */
  async getPhoneNumberRaw(
    requestParameters: GetPhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberDto>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling getPhoneNumber.'
      );
    }

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

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

  /**
   * Get a phone number by ID
   * Get a phone number by ID
   */
  async getPhoneNumber(
    requestParameters: GetPhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberDto> {
    const response = await this.getPhoneNumberRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get a phone number by name
   * Get a phone number by name
   */
  async getPhoneNumberByNameRaw(
    requestParameters: GetPhoneNumberByNameRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberDto>> {
    if (
      requestParameters.name === null ||
      requestParameters.name === undefined
    ) {
      throw new runtime.RequiredError(
        'name',
        'Required parameter requestParameters.name was null or undefined when calling getPhoneNumberByName.'
      );
    }

    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: `/phone/numbers/by-name`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get a phone number by name
   * Get a phone number by name
   */
  async getPhoneNumberByName(
    requestParameters: GetPhoneNumberByNameRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberDto> {
    const response = await this.getPhoneNumberByNameRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get a phone number by phone number
   * Get a phone number by phone number
   */
  async getPhoneNumberByPhoneNumberRaw(
    requestParameters: GetPhoneNumberByPhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberDto>> {
    if (
      requestParameters.phoneNumber === null ||
      requestParameters.phoneNumber === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumber',
        'Required parameter requestParameters.phoneNumber was null or undefined when calling getPhoneNumberByPhoneNumber.'
      );
    }

    const queryParameters: any = {};

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

    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: `/phone/numbers/by-phone-number`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get a phone number by phone number
   * Get a phone number by phone number
   */
  async getPhoneNumberByPhoneNumber(
    requestParameters: GetPhoneNumberByPhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberDto> {
    const response = await this.getPhoneNumberByPhoneNumberRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Lookup line type intelligence for a phone number
   * Get line type intelligence for a phone number
   */
  async getPhoneNumberLineTypeIntelligenceRaw(
    requestParameters: GetPhoneNumberLineTypeIntelligenceRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberLineTypeLookupDto>> {
    if (
      requestParameters.validatePhoneNumberOptions === null ||
      requestParameters.validatePhoneNumberOptions === undefined
    ) {
      throw new runtime.RequiredError(
        'validatePhoneNumberOptions',
        'Required parameter requestParameters.validatePhoneNumberOptions was null or undefined when calling getPhoneNumberLineTypeIntelligence.'
      );
    }

    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: `/phone/validate/line-type-intelligence`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: ValidatePhoneNumberOptionsToJSON(
          requestParameters.validatePhoneNumberOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Lookup line type intelligence for a phone number
   * Get line type intelligence for a phone number
   */
  async getPhoneNumberLineTypeIntelligence(
    requestParameters: GetPhoneNumberLineTypeIntelligenceRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberLineTypeLookupDto> {
    const response = await this.getPhoneNumberLineTypeIntelligenceRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get a released or deleted phone numbers
   * Get phone number release
   */
  async getPhoneNumberReleaseRaw(
    requestParameters: GetPhoneNumberReleaseRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberReleaseProjection>> {
    if (
      requestParameters.releaseId === null ||
      requestParameters.releaseId === undefined
    ) {
      throw new runtime.RequiredError(
        'releaseId',
        'Required parameter requestParameters.releaseId was null or undefined when calling getPhoneNumberRelease.'
      );
    }

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

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

  /**
   * Get a released or deleted phone numbers
   * Get phone number release
   */
  async getPhoneNumberRelease(
    requestParameters: GetPhoneNumberReleaseRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberReleaseProjection> {
    const response = await this.getPhoneNumberReleaseRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get tags for a specific phone number
   * Get phone number tags
   */
  async getPhoneNumberTagsRaw(
    requestParameters: GetPhoneNumberTagsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<Array<string>>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling getPhoneNumberTags.'
      );
    }

    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: `/phone/numbers/{phoneNumberId}/tags`.replace(
          `{${'phoneNumberId'}}`,
          encodeURIComponent(String(requestParameters.phoneNumberId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.JSONApiResponse<any>(response);
  }

  /**
   * Get tags for a specific phone number
   * Get phone number tags
   */
  async getPhoneNumberTags(
    requestParameters: GetPhoneNumberTagsRequest,
    initOverrides?: RequestInit
  ): Promise<Array<string>> {
    const response = await this.getPhoneNumberTagsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * List phone numbers for account
   * Get phone numbers
   */
  async getPhoneNumbersRaw(
    requestParameters: GetPhoneNumbersRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PagePhoneNumberProjection>> {
    const queryParameters: any = {};

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

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

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

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

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

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

    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.search !== undefined) {
      queryParameters['search'] = requestParameters.search;
    }

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

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

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

    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: `/phone/numbers`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List phone numbers for account
   * Get phone numbers
   */
  async getPhoneNumbers(
    requestParameters: GetPhoneNumbersRequest,
    initOverrides?: RequestInit
  ): Promise<PagePhoneNumberProjection> {
    const response = await this.getPhoneNumbersRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get phone number plans
   * Get phone plans
   */
  async getPhonePlansRaw(
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<Array<PhonePlanDto>>> {
    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: `/phone/plans`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get phone number plans
   * Get phone plans
   */
  async getPhonePlans(
    initOverrides?: RequestInit
  ): Promise<Array<PhonePlanDto>> {
    const response = await this.getPhonePlansRaw(initOverrides);
    return await response.value();
  }

  /**
   * Get phone plans availability
   */
  async getPhonePlansAvailabilityRaw(
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhonePlanAvailability>> {
    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: `/phone/plans/availability`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get phone plans availability
   */
  async getPhonePlansAvailability(
    initOverrides?: RequestInit
  ): Promise<PhonePlanAvailability> {
    const response = await this.getPhonePlansAvailabilityRaw(initOverrides);
    return await response.value();
  }

  /**
   * Get phone pool details by ID
   * Get phone pool
   */
  async getPhonePoolRaw(
    requestParameters: GetPhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhonePoolDetailDto>> {
    if (
      requestParameters.poolId === null ||
      requestParameters.poolId === undefined
    ) {
      throw new runtime.RequiredError(
        'poolId',
        'Required parameter requestParameters.poolId was null or undefined when calling getPhonePool.'
      );
    }

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

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

  /**
   * Get phone pool details by ID
   * Get phone pool
   */
  async getPhonePool(
    requestParameters: GetPhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<PhonePoolDetailDto> {
    const response = await this.getPhonePoolRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get phone pool details by name
   * Get phone pool by name
   */
  async getPhonePoolByNameRaw(
    requestParameters: GetPhonePoolByNameRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhonePoolDetailDto>> {
    if (
      requestParameters.name === null ||
      requestParameters.name === undefined
    ) {
      throw new runtime.RequiredError(
        'name',
        'Required parameter requestParameters.name was null or undefined when calling getPhonePoolByName.'
      );
    }

    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: `/phone/pools/by-name`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get phone pool details by name
   * Get phone pool by name
   */
  async getPhonePoolByName(
    requestParameters: GetPhonePoolByNameRequest,
    initOverrides?: RequestInit
  ): Promise<PhonePoolDetailDto> {
    const response = await this.getPhonePoolByNameRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * List phone pools for the authenticated user
   * Get phone pools
   */
  async getPhonePoolsRaw(
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<Array<PhonePoolDto>>> {
    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: `/phone/pools`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List phone pools for the authenticated user
   * Get phone pools
   */
  async getPhonePools(
    initOverrides?: RequestInit
  ): Promise<Array<PhonePoolDto>> {
    const response = await this.getPhonePoolsRaw(initOverrides);
    return await response.value();
  }

  /**
   * Get supported provider-country variant capabilities for advanced provisioning
   * Get phone provisioning capabilities
   */
  async getPhoneProvisioningCapabilitiesRaw(
    requestParameters: GetPhoneProvisioningCapabilitiesRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneProviderCapabilitiesResult>> {
    if (
      requestParameters.phoneCountry === null ||
      requestParameters.phoneCountry === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneCountry',
        'Required parameter requestParameters.phoneCountry was null or undefined when calling getPhoneProvisioningCapabilities.'
      );
    }

    const queryParameters: any = {};

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

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

    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: `/phone/provisioning/capabilities`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get supported provider-country variant capabilities for advanced provisioning
   * Get phone provisioning capabilities
   */
  async getPhoneProvisioningCapabilities(
    requestParameters: GetPhoneProvisioningCapabilitiesRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneProviderCapabilitiesResult> {
    const response = await this.getPhoneProvisioningCapabilitiesRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get advanced phone provisioning job status
   * Get phone provisioning job
   */
  async getPhoneProvisioningJobRaw(
    requestParameters: GetPhoneProvisioningJobRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneProvisioningJobDto>> {
    if (
      requestParameters.jobId === null ||
      requestParameters.jobId === undefined
    ) {
      throw new runtime.RequiredError(
        'jobId',
        'Required parameter requestParameters.jobId was null or undefined when calling getPhoneProvisioningJob.'
      );
    }

    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: `/phone/provisioning/jobs/{jobId}`.replace(
          `{${'jobId'}}`,
          encodeURIComponent(String(requestParameters.jobId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get advanced phone provisioning job status
   * Get phone provisioning job
   */
  async getPhoneProvisioningJob(
    requestParameters: GetPhoneProvisioningJobRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneProvisioningJobDto> {
    const response = await this.getPhoneProvisioningJobRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get a specific SMS prepaid credit balance for the authenticated account
   * Get SMS prepaid credit
   */
  async getPhoneSmsPrepaidCreditRaw(
    requestParameters: GetPhoneSmsPrepaidCreditRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneSmsPrepaidCreditDto>> {
    if (
      requestParameters.creditId === null ||
      requestParameters.creditId === undefined
    ) {
      throw new runtime.RequiredError(
        'creditId',
        'Required parameter requestParameters.creditId was null or undefined when calling getPhoneSmsPrepaidCredit.'
      );
    }

    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: `/phone/sms-prepaid-credits/{creditId}`.replace(
          `{${'creditId'}}`,
          encodeURIComponent(String(requestParameters.creditId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get a specific SMS prepaid credit balance for the authenticated account
   * Get SMS prepaid credit
   */
  async getPhoneSmsPrepaidCredit(
    requestParameters: GetPhoneSmsPrepaidCreditRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneSmsPrepaidCreditDto> {
    const response = await this.getPhoneSmsPrepaidCreditRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * List SMS prepaid credits for the authenticated account
   * Get SMS prepaid credits
   */
  async getPhoneSmsPrepaidCreditsRaw(
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneSmsPrepaidCreditsDto>> {
    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: `/phone/sms-prepaid-credits`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * List SMS prepaid credits for the authenticated account
   * Get SMS prepaid credits
   */
  async getPhoneSmsPrepaidCredits(
    initOverrides?: RequestInit
  ): Promise<PhoneSmsPrepaidCreditsDto> {
    const response = await this.getPhoneSmsPrepaidCreditsRaw(initOverrides);
    return await response.value();
  }

  /**
   * Get overview of assigned phones
   * Get phone summary
   */
  async getPhoneSummaryRaw(
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneSummaryDto>> {
    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: `/phone/summary`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get overview of assigned phones
   * Get phone summary
   */
  async getPhoneSummary(initOverrides?: RequestInit): Promise<PhoneSummaryDto> {
    const response = await this.getPhoneSummaryRaw(initOverrides);
    return await response.value();
  }

  /**
   * List all unique tags used by your phone numbers
   * Get phone tags
   */
  async getPhoneTagsRaw(
    requestParameters: GetPhoneTagsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<Array<string>>> {
    const queryParameters: any = {};

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

    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: `/phone/tags`,
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.JSONApiResponse<any>(response);
  }

  /**
   * List all unique tags used by your phone numbers
   * Get phone tags
   */
  async getPhoneTags(
    requestParameters: GetPhoneTagsRequest,
    initOverrides?: RequestInit
  ): Promise<Array<string>> {
    const response = await this.getPhoneTagsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get sent SMS messages for a phone number
   * List sent TXT messages for a phone number
   */
  async getSentSmsByPhoneNumberRaw(
    requestParameters: GetSentSmsByPhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PageSentSmsProjection>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling getSentSmsByPhoneNumber.'
      );
    }

    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.search !== undefined) {
      queryParameters['search'] = requestParameters.search;
    }

    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: `/phone/numbers/{phoneNumberId}/sms-sent`.replace(
          `{${'phoneNumberId'}}`,
          encodeURIComponent(String(requestParameters.phoneNumberId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get sent SMS messages for a phone number
   * List sent TXT messages for a phone number
   */
  async getSentSmsByPhoneNumber(
    requestParameters: GetSentSmsByPhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<PageSentSmsProjection> {
    const response = await this.getSentSmsByPhoneNumberRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Get SMS messages for a phone number
   * List SMS messages for a phone number
   */
  async getSmsByPhoneNumberRaw(
    requestParameters: GetSmsByPhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PageSmsProjection>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling getSmsByPhoneNumber.'
      );
    }

    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.unreadOnly !== undefined) {
      queryParameters['unreadOnly'] = requestParameters.unreadOnly;
    }

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

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

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

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

    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: `/phone/numbers/{phoneNumberId}/sms`.replace(
          `{${'phoneNumberId'}}`,
          encodeURIComponent(String(requestParameters.phoneNumberId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Get SMS messages for a phone number
   * List SMS messages for a phone number
   */
  async getSmsByPhoneNumber(
    requestParameters: GetSmsByPhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<PageSmsProjection> {
    const response = await this.getSmsByPhoneNumberRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Reassign phone number that was released or deleted
   * Reassign phone number release
   */
  async reassignPhoneNumberReleaseRaw(
    requestParameters: ReassignPhoneNumberReleaseRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberDto>> {
    if (
      requestParameters.releaseId === null ||
      requestParameters.releaseId === undefined
    ) {
      throw new runtime.RequiredError(
        'releaseId',
        'Required parameter requestParameters.releaseId was null or undefined when calling reassignPhoneNumberRelease.'
      );
    }

    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: `/phone/releases/{releaseId}/reassign`.replace(
          `{${'releaseId'}}`,
          encodeURIComponent(String(requestParameters.releaseId))
        ),
        method: 'GET',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Reassign phone number that was released or deleted
   * Reassign phone number release
   */
  async reassignPhoneNumberRelease(
    requestParameters: ReassignPhoneNumberReleaseRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberDto> {
    const response = await this.reassignPhoneNumberReleaseRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Release an active phone pool lease
   * Release phone pool lease
   */
  async releasePhonePoolLeaseRaw(
    requestParameters: ReleasePhonePoolLeaseRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    if (
      requestParameters.poolId === null ||
      requestParameters.poolId === undefined
    ) {
      throw new runtime.RequiredError(
        'poolId',
        'Required parameter requestParameters.poolId was null or undefined when calling releasePhonePoolLease.'
      );
    }

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

    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: `/phone/pools/{poolId}/leases/{leaseId}`
          .replace(
            `{${'poolId'}}`,
            encodeURIComponent(String(requestParameters.poolId))
          )
          .replace(
            `{${'leaseId'}}`,
            encodeURIComponent(String(requestParameters.leaseId))
          ),
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Release an active phone pool lease
   * Release phone pool lease
   */
  async releasePhonePoolLease(
    requestParameters: ReleasePhonePoolLeaseRequest,
    initOverrides?: RequestInit
  ): Promise<void> {
    await this.releasePhonePoolLeaseRaw(requestParameters, initOverrides);
  }

  /**
   * Remove a phone number from a pool. If the number is leased from this pool the lease is released.
   * Remove phone number from phone pool
   */
  async removePhoneNumberFromPhonePoolRaw(
    requestParameters: RemovePhoneNumberFromPhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    if (
      requestParameters.poolId === null ||
      requestParameters.poolId === undefined
    ) {
      throw new runtime.RequiredError(
        'poolId',
        'Required parameter requestParameters.poolId was null or undefined when calling removePhoneNumberFromPhonePool.'
      );
    }

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

    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: `/phone/pools/{poolId}/numbers/{phoneNumberId}`
          .replace(
            `{${'poolId'}}`,
            encodeURIComponent(String(requestParameters.poolId))
          )
          .replace(
            `{${'phoneNumberId'}}`,
            encodeURIComponent(String(requestParameters.phoneNumberId))
          ),
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Remove a phone number from a pool. If the number is leased from this pool the lease is released.
   * Remove phone number from phone pool
   */
  async removePhoneNumberFromPhonePool(
    requestParameters: RemovePhoneNumberFromPhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<void> {
    await this.removePhoneNumberFromPhonePoolRaw(
      requestParameters,
      initOverrides
    );
  }

  /**
   * Remove one or more tags from a phone number
   * Remove phone number tags
   */
  async removePhoneNumberTagsRaw(
    requestParameters: RemovePhoneNumberTagsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberDto>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling removePhoneNumberTags.'
      );
    }

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

    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: `/phone/numbers/{phoneNumberId}/tags`.replace(
          `{${'phoneNumberId'}}`,
          encodeURIComponent(String(requestParameters.phoneNumberId))
        ),
        method: 'DELETE',
        headers: headerParameters,
        query: queryParameters,
        body: PhoneNumberTagsOptionsToJSON(
          requestParameters.phoneNumberTagsOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Remove one or more tags from a phone number
   * Remove phone number tags
   */
  async removePhoneNumberTags(
    requestParameters: RemovePhoneNumberTagsRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberDto> {
    const response = await this.removePhoneNumberTagsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Search available numbers for advanced provisioning
   * Search available phone numbers
   */
  async searchAvailablePhoneNumbersRaw(
    requestParameters: SearchAvailablePhoneNumbersRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<AvailablePhoneNumbersResult>> {
    if (
      requestParameters.searchAvailablePhoneNumbersOptions === null ||
      requestParameters.searchAvailablePhoneNumbersOptions === undefined
    ) {
      throw new runtime.RequiredError(
        'searchAvailablePhoneNumbersOptions',
        'Required parameter requestParameters.searchAvailablePhoneNumbersOptions was null or undefined when calling searchAvailablePhoneNumbers.'
      );
    }

    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: `/phone/provisioning/search`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: SearchAvailablePhoneNumbersOptionsToJSON(
          requestParameters.searchAvailablePhoneNumbersOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Search available numbers for advanced provisioning
   * Search available phone numbers
   */
  async searchAvailablePhoneNumbers(
    requestParameters: SearchAvailablePhoneNumbersRequest,
    initOverrides?: RequestInit
  ): Promise<AvailablePhoneNumbersResult> {
    const response = await this.searchAvailablePhoneNumbersRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Send SMS from a phone number
   * Send TXT message from a phone number
   */
  async sendSmsFromPhoneNumberRaw(
    requestParameters: SendSmsFromPhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<SentSmsDto>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling sendSmsFromPhoneNumber.'
      );
    }

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

    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: `/phone/numbers/{phoneNumberId}/sms`.replace(
          `{${'phoneNumberId'}}`,
          encodeURIComponent(String(requestParameters.phoneNumberId))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: SmsSendOptionsToJSON(requestParameters.smsSendOptions),
      },
      initOverrides
    );

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

  /**
   * Send SMS from a phone number
   * Send TXT message from a phone number
   */
  async sendSmsFromPhoneNumber(
    requestParameters: SendSmsFromPhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<SentSmsDto> {
    const response = await this.sendSmsFromPhoneNumberRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Give or revoke consent for phone usage
   * Set consent status
   */
  async setConsentStatusRaw(
    requestParameters: SetConsentStatusRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<ConsentStatusDto>> {
    if (
      requestParameters.agree === null ||
      requestParameters.agree === undefined
    ) {
      throw new runtime.RequiredError(
        'agree',
        'Required parameter requestParameters.agree was null or undefined when calling setConsentStatus.'
      );
    }

    const queryParameters: any = {};

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

    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: `/phone/consent`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
      },
      initOverrides
    );

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

  /**
   * Give or revoke consent for phone usage
   * Set consent status
   */
  async setConsentStatus(
    requestParameters: SetConsentStatusRequest,
    initOverrides?: RequestInit
  ): Promise<ConsentStatusDto> {
    const response = await this.setConsentStatusRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Set and return new favorite state for a phone
   * Set phone favourited state
   */
  async setPhoneFavouritedRaw(
    requestParameters: SetPhoneFavouritedRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberDto>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling setPhoneFavourited.'
      );
    }

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

    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: `/phone/numbers/{phoneNumberId}/favourite`.replace(
          `{${'phoneNumberId'}}`,
          encodeURIComponent(String(requestParameters.phoneNumberId))
        ),
        method: 'PUT',
        headers: headerParameters,
        query: queryParameters,
        body: SetPhoneFavouritedOptionsToJSON(
          requestParameters.setPhoneFavouritedOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Set and return new favorite state for a phone
   * Set phone favourited state
   */
  async setPhoneFavourited(
    requestParameters: SetPhoneFavouritedRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberDto> {
    const response = await this.setPhoneFavouritedRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Replace all tags on a phone number
   * Set phone number tags
   */
  async setPhoneNumberTagsRaw(
    requestParameters: SetPhoneNumberTagsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberDto>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling setPhoneNumberTags.'
      );
    }

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

    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: `/phone/numbers/{phoneNumberId}/tags`.replace(
          `{${'phoneNumberId'}}`,
          encodeURIComponent(String(requestParameters.phoneNumberId))
        ),
        method: 'PUT',
        headers: headerParameters,
        query: queryParameters,
        body: PhoneNumberTagsOptionsToJSON(
          requestParameters.phoneNumberTagsOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Replace all tags on a phone number
   * Set phone number tags
   */
  async setPhoneNumberTags(
    requestParameters: SetPhoneNumberTagsRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberDto> {
    const response = await this.setPhoneNumberTagsRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Test a phone number by sending an SMS to it. NOTE this is only for internal use to check that a phone number is working. For end-to-end phone testing see https://docs.mailslurp.com/txt-sms/
   * Test sending an SMS to a number
   */
  async testPhoneNumberSendSmsRaw(
    requestParameters: TestPhoneNumberSendSmsRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<void>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling testPhoneNumberSendSms.'
      );
    }

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

    const queryParameters: any = {};

    const headerParameters: runtime.HTTPHeaders = {};

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

    if (
      requestParameters.xTestId !== undefined &&
      requestParameters.xTestId !== null
    ) {
      headerParameters['x-test-id'] = String(requestParameters.xTestId);
    }

    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: `/phone/numbers/{phoneNumberId}/test`.replace(
          `{${'phoneNumberId'}}`,
          encodeURIComponent(String(requestParameters.phoneNumberId))
        ),
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: TestPhoneNumberOptionsToJSON(
          requestParameters.testPhoneNumberOptions
        ),
      },
      initOverrides
    );

    return new runtime.VoidApiResponse(response);
  }

  /**
   * Test a phone number by sending an SMS to it. NOTE this is only for internal use to check that a phone number is working. For end-to-end phone testing see https://docs.mailslurp.com/txt-sms/
   * Test sending an SMS to a number
   */
  async testPhoneNumberSendSms(
    requestParameters: TestPhoneNumberSendSmsRequest,
    initOverrides?: RequestInit
  ): Promise<void> {
    await this.testPhoneNumberSendSmsRaw(requestParameters, initOverrides);
  }

  /**
   * Set field for phone number
   * Update a phone number
   */
  async updatePhoneNumberRaw(
    requestParameters: UpdatePhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberDto>> {
    if (
      requestParameters.phoneNumberId === null ||
      requestParameters.phoneNumberId === undefined
    ) {
      throw new runtime.RequiredError(
        'phoneNumberId',
        'Required parameter requestParameters.phoneNumberId was null or undefined when calling updatePhoneNumber.'
      );
    }

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

    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: `/phone/numbers/{phoneNumberId}`.replace(
          `{${'phoneNumberId'}}`,
          encodeURIComponent(String(requestParameters.phoneNumberId))
        ),
        method: 'PUT',
        headers: headerParameters,
        query: queryParameters,
        body: UpdatePhoneNumberOptionsToJSON(
          requestParameters.updatePhoneNumberOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Set field for phone number
   * Update a phone number
   */
  async updatePhoneNumber(
    requestParameters: UpdatePhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberDto> {
    const response = await this.updatePhoneNumberRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Update phone pool metadata such as name or description
   * Update phone pool
   */
  async updatePhonePoolRaw(
    requestParameters: UpdatePhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhonePoolDetailDto>> {
    if (
      requestParameters.poolId === null ||
      requestParameters.poolId === undefined
    ) {
      throw new runtime.RequiredError(
        'poolId',
        'Required parameter requestParameters.poolId was null or undefined when calling updatePhonePool.'
      );
    }

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

    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: `/phone/pools/{poolId}`.replace(
          `{${'poolId'}}`,
          encodeURIComponent(String(requestParameters.poolId))
        ),
        method: 'PUT',
        headers: headerParameters,
        query: queryParameters,
        body: UpdatePhonePoolOptionsToJSON(
          requestParameters.updatePhonePoolOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Update phone pool metadata such as name or description
   * Update phone pool
   */
  async updatePhonePool(
    requestParameters: UpdatePhonePoolRequest,
    initOverrides?: RequestInit
  ): Promise<PhonePoolDetailDto> {
    const response = await this.updatePhonePoolRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }

  /**
   * Validate a phone number
   * Verify validity of a phone number
   */
  async validatePhoneNumberRaw(
    requestParameters: ValidatePhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<runtime.ApiResponse<PhoneNumberValidationDto>> {
    if (
      requestParameters.validatePhoneNumberOptions === null ||
      requestParameters.validatePhoneNumberOptions === undefined
    ) {
      throw new runtime.RequiredError(
        'validatePhoneNumberOptions',
        'Required parameter requestParameters.validatePhoneNumberOptions was null or undefined when calling validatePhoneNumber.'
      );
    }

    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: `/phone/validate`,
        method: 'POST',
        headers: headerParameters,
        query: queryParameters,
        body: ValidatePhoneNumberOptionsToJSON(
          requestParameters.validatePhoneNumberOptions
        ),
      },
      initOverrides
    );

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

  /**
   * Validate a phone number
   * Verify validity of a phone number
   */
  async validatePhoneNumber(
    requestParameters: ValidatePhoneNumberRequest,
    initOverrides?: RequestInit
  ): Promise<PhoneNumberValidationDto> {
    const response = await this.validatePhoneNumberRaw(
      requestParameters,
      initOverrides
    );
    return await response.value();
  }
}

/**
 * @export
 * @enum {string}
 */
export enum GetAllPhoneNumberReleasesSortEnum {
  ASC = 'ASC',
  DESC = 'DESC',
}
/**
 * @export
 * @enum {string}
 */
export enum GetPhoneNumbersPhoneCountryEnum {
  US = 'US',
  GB = 'GB',
  AU = 'AU',
  CA = 'CA',
  EE = 'EE',
  HK = 'HK',
  PL = 'PL',
  PT = 'PT',
  NL = 'NL',
  IL = 'IL',
  FI = 'FI',
  SE = 'SE',
}
/**
 * @export
 * @enum {string}
 */
export enum GetPhoneNumbersSortEnum {
  ASC = 'ASC',
  DESC = 'DESC',
}
/**
 * @export
 * @enum {string}
 */
export enum GetPhoneProvisioningCapabilitiesPhoneCountryEnum {
  US = 'US',
  GB = 'GB',
  AU = 'AU',
  CA = 'CA',
  EE = 'EE',
  HK = 'HK',
  PL = 'PL',
  PT = 'PT',
  NL = 'NL',
  IL = 'IL',
  FI = 'FI',
  SE = 'SE',
}
/**
 * @export
 * @enum {string}
 */
export enum GetSentSmsByPhoneNumberSortEnum {
  ASC = 'ASC',
  DESC = 'DESC',
}
/**
 * @export
 * @enum {string}
 */
export enum GetSmsByPhoneNumberSortEnum {
  ASC = 'ASC',
  DESC = 'DESC',
}