@ondewo/csi-client-typescript/api/ondewo/t2s/text-to-speech_pb.d.ts

ONDEWO Conversation System Integration (CSI) Client library for Typescript

import * as jspb from 'google-protobuf'

import * as google_protobuf_empty_pb from 'google-protobuf/google/protobuf/empty_pb'; // proto import: "google/protobuf/empty.proto"
import * as google_protobuf_struct_pb from 'google-protobuf/google/protobuf/struct_pb'; // proto import: "google/protobuf/struct.proto"


export class SynthesizeRequest extends jspb.Message {
  getText(): string;
  setText(value: string): SynthesizeRequest;

  getConfig(): RequestConfig | undefined;
  setConfig(value?: RequestConfig): SynthesizeRequest;
  hasConfig(): boolean;
  clearConfig(): SynthesizeRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SynthesizeRequest.AsObject;
  static toObject(includeInstance: boolean, msg: SynthesizeRequest): SynthesizeRequest.AsObject;
  static serializeBinaryToWriter(message: SynthesizeRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SynthesizeRequest;
  static deserializeBinaryFromReader(message: SynthesizeRequest, reader: jspb.BinaryReader): SynthesizeRequest;
}

export namespace SynthesizeRequest {
  export type AsObject = {
    text: string,
    config?: RequestConfig.AsObject,
  }
}

export class BatchSynthesizeRequest extends jspb.Message {
  getBatchRequestList(): Array<SynthesizeRequest>;
  setBatchRequestList(value: Array<SynthesizeRequest>): BatchSynthesizeRequest;
  clearBatchRequestList(): BatchSynthesizeRequest;
  addBatchRequest(value?: SynthesizeRequest, index?: number): SynthesizeRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): BatchSynthesizeRequest.AsObject;
  static toObject(includeInstance: boolean, msg: BatchSynthesizeRequest): BatchSynthesizeRequest.AsObject;
  static serializeBinaryToWriter(message: BatchSynthesizeRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): BatchSynthesizeRequest;
  static deserializeBinaryFromReader(message: BatchSynthesizeRequest, reader: jspb.BinaryReader): BatchSynthesizeRequest;
}

export namespace BatchSynthesizeRequest {
  export type AsObject = {
    batchRequestList: Array<SynthesizeRequest.AsObject>,
  }
}

export class BatchSynthesizeResponse extends jspb.Message {
  getBatchResponseList(): Array<SynthesizeResponse>;
  setBatchResponseList(value: Array<SynthesizeResponse>): BatchSynthesizeResponse;
  clearBatchResponseList(): BatchSynthesizeResponse;
  addBatchResponse(value?: SynthesizeResponse, index?: number): SynthesizeResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): BatchSynthesizeResponse.AsObject;
  static toObject(includeInstance: boolean, msg: BatchSynthesizeResponse): BatchSynthesizeResponse.AsObject;
  static serializeBinaryToWriter(message: BatchSynthesizeResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): BatchSynthesizeResponse;
  static deserializeBinaryFromReader(message: BatchSynthesizeResponse, reader: jspb.BinaryReader): BatchSynthesizeResponse;
}

export namespace BatchSynthesizeResponse {
  export type AsObject = {
    batchResponseList: Array<SynthesizeResponse.AsObject>,
  }
}

export class RequestConfig extends jspb.Message {
  getT2sPipelineId(): string;
  setT2sPipelineId(value: string): RequestConfig;

  getLengthScale(): number;
  setLengthScale(value: number): RequestConfig;

  getNoiseScale(): number;
  setNoiseScale(value: number): RequestConfig;

  getSampleRate(): number;
  setSampleRate(value: number): RequestConfig;

  getPcm(): Pcm;
  setPcm(value: Pcm): RequestConfig;

  getAudioFormat(): AudioFormat;
  setAudioFormat(value: AudioFormat): RequestConfig;

  getUseCache(): boolean;
  setUseCache(value: boolean): RequestConfig;

  getNormalizer(): string;
  setNormalizer(value: string): RequestConfig;

  getT2sServiceConfig(): google_protobuf_struct_pb.Struct | undefined;
  setT2sServiceConfig(value?: google_protobuf_struct_pb.Struct): RequestConfig;
  hasT2sServiceConfig(): boolean;
  clearT2sServiceConfig(): RequestConfig;

  getT2sCloudProviderConfig(): T2sCloudProviderConfig | undefined;
  setT2sCloudProviderConfig(value?: T2sCloudProviderConfig): RequestConfig;
  hasT2sCloudProviderConfig(): boolean;
  clearT2sCloudProviderConfig(): RequestConfig;

  getOneofLengthScaleCase(): RequestConfig.OneofLengthScaleCase;

  getOneofNoiseScaleCase(): RequestConfig.OneofNoiseScaleCase;

  getOneofSampleRateCase(): RequestConfig.OneofSampleRateCase;

  getOneofPcmCase(): RequestConfig.OneofPcmCase;

  getOneofAudioformatCase(): RequestConfig.OneofAudioformatCase;

  getOneofUseCacheCase(): RequestConfig.OneofUseCacheCase;

  getOneofNormalizerCase(): RequestConfig.OneofNormalizerCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RequestConfig.AsObject;
  static toObject(includeInstance: boolean, msg: RequestConfig): RequestConfig.AsObject;
  static serializeBinaryToWriter(message: RequestConfig, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RequestConfig;
  static deserializeBinaryFromReader(message: RequestConfig, reader: jspb.BinaryReader): RequestConfig;
}

export namespace RequestConfig {
  export type AsObject = {
    t2sPipelineId: string,
    lengthScale: number,
    noiseScale: number,
    sampleRate: number,
    pcm: Pcm,
    audioFormat: AudioFormat,
    useCache: boolean,
    normalizer: string,
    t2sServiceConfig?: google_protobuf_struct_pb.Struct.AsObject,
    t2sCloudProviderConfig?: T2sCloudProviderConfig.AsObject,
  }

  export enum OneofLengthScaleCase { 
    ONEOF_LENGTH_SCALE_NOT_SET = 0,
    LENGTH_SCALE = 2,
  }

  export enum OneofNoiseScaleCase { 
    ONEOF_NOISE_SCALE_NOT_SET = 0,
    NOISE_SCALE = 3,
  }

  export enum OneofSampleRateCase { 
    ONEOF_SAMPLE_RATE_NOT_SET = 0,
    SAMPLE_RATE = 4,
  }

  export enum OneofPcmCase { 
    ONEOF_PCM_NOT_SET = 0,
    PCM = 5,
  }

  export enum OneofAudioformatCase { 
    ONEOF_AUDIOFORMAT_NOT_SET = 0,
    AUDIO_FORMAT = 6,
  }

  export enum OneofUseCacheCase { 
    ONEOF_USE_CACHE_NOT_SET = 0,
    USE_CACHE = 7,
  }

  export enum OneofNormalizerCase { 
    ONEOF_NORMALIZER_NOT_SET = 0,
    NORMALIZER = 8,
  }

  export enum T2sServiceConfigCase { 
    _T2S_SERVICE_CONFIG_NOT_SET = 0,
    T2S_SERVICE_CONFIG = 9,
  }

  export enum T2sCloudProviderConfigCase { 
    _T2S_CLOUD_PROVIDER_CONFIG_NOT_SET = 0,
    T2S_CLOUD_PROVIDER_CONFIG = 10,
  }
}

export class T2sCloudProviderConfig extends jspb.Message {
  getT2sCloudProviderConfigElevenlabs(): T2sCloudProviderConfigElevenLabs | undefined;
  setT2sCloudProviderConfigElevenlabs(value?: T2sCloudProviderConfigElevenLabs): T2sCloudProviderConfig;
  hasT2sCloudProviderConfigElevenlabs(): boolean;
  clearT2sCloudProviderConfigElevenlabs(): T2sCloudProviderConfig;

  getT2sCloudProviderConfigGoogle(): T2sCloudProviderConfigGoogle | undefined;
  setT2sCloudProviderConfigGoogle(value?: T2sCloudProviderConfigGoogle): T2sCloudProviderConfig;
  hasT2sCloudProviderConfigGoogle(): boolean;
  clearT2sCloudProviderConfigGoogle(): T2sCloudProviderConfig;

  getT2sCloudProviderConfigMicrosoft(): T2sCloudProviderConfigMicrosoft | undefined;
  setT2sCloudProviderConfigMicrosoft(value?: T2sCloudProviderConfigMicrosoft): T2sCloudProviderConfig;
  hasT2sCloudProviderConfigMicrosoft(): boolean;
  clearT2sCloudProviderConfigMicrosoft(): T2sCloudProviderConfig;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2sCloudProviderConfig.AsObject;
  static toObject(includeInstance: boolean, msg: T2sCloudProviderConfig): T2sCloudProviderConfig.AsObject;
  static serializeBinaryToWriter(message: T2sCloudProviderConfig, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2sCloudProviderConfig;
  static deserializeBinaryFromReader(message: T2sCloudProviderConfig, reader: jspb.BinaryReader): T2sCloudProviderConfig;
}

export namespace T2sCloudProviderConfig {
  export type AsObject = {
    t2sCloudProviderConfigElevenlabs?: T2sCloudProviderConfigElevenLabs.AsObject,
    t2sCloudProviderConfigGoogle?: T2sCloudProviderConfigGoogle.AsObject,
    t2sCloudProviderConfigMicrosoft?: T2sCloudProviderConfigMicrosoft.AsObject,
  }
}

export class T2sCloudProviderConfigElevenLabs extends jspb.Message {
  getStability(): number;
  setStability(value: number): T2sCloudProviderConfigElevenLabs;

  getSimilarityBoost(): number;
  setSimilarityBoost(value: number): T2sCloudProviderConfigElevenLabs;

  getStyle(): number;
  setStyle(value: number): T2sCloudProviderConfigElevenLabs;

  getUseSpeakerBoost(): boolean;
  setUseSpeakerBoost(value: boolean): T2sCloudProviderConfigElevenLabs;

  getApplyTextNormalization(): string;
  setApplyTextNormalization(value: string): T2sCloudProviderConfigElevenLabs;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2sCloudProviderConfigElevenLabs.AsObject;
  static toObject(includeInstance: boolean, msg: T2sCloudProviderConfigElevenLabs): T2sCloudProviderConfigElevenLabs.AsObject;
  static serializeBinaryToWriter(message: T2sCloudProviderConfigElevenLabs, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2sCloudProviderConfigElevenLabs;
  static deserializeBinaryFromReader(message: T2sCloudProviderConfigElevenLabs, reader: jspb.BinaryReader): T2sCloudProviderConfigElevenLabs;
}

export namespace T2sCloudProviderConfigElevenLabs {
  export type AsObject = {
    stability: number,
    similarityBoost: number,
    style: number,
    useSpeakerBoost: boolean,
    applyTextNormalization: string,
  }
}

export class T2sCloudProviderConfigMicrosoft extends jspb.Message {
  getUseDefaultSpeaker(): boolean;
  setUseDefaultSpeaker(value: boolean): T2sCloudProviderConfigMicrosoft;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2sCloudProviderConfigMicrosoft.AsObject;
  static toObject(includeInstance: boolean, msg: T2sCloudProviderConfigMicrosoft): T2sCloudProviderConfigMicrosoft.AsObject;
  static serializeBinaryToWriter(message: T2sCloudProviderConfigMicrosoft, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2sCloudProviderConfigMicrosoft;
  static deserializeBinaryFromReader(message: T2sCloudProviderConfigMicrosoft, reader: jspb.BinaryReader): T2sCloudProviderConfigMicrosoft;
}

export namespace T2sCloudProviderConfigMicrosoft {
  export type AsObject = {
    useDefaultSpeaker: boolean,
  }
}

export class T2sCloudProviderConfigGoogle extends jspb.Message {
  getSpeakingRate(): number;
  setSpeakingRate(value: number): T2sCloudProviderConfigGoogle;

  getVolumeGainDb(): number;
  setVolumeGainDb(value: number): T2sCloudProviderConfigGoogle;

  getPitch(): number;
  setPitch(value: number): T2sCloudProviderConfigGoogle;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2sCloudProviderConfigGoogle.AsObject;
  static toObject(includeInstance: boolean, msg: T2sCloudProviderConfigGoogle): T2sCloudProviderConfigGoogle.AsObject;
  static serializeBinaryToWriter(message: T2sCloudProviderConfigGoogle, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2sCloudProviderConfigGoogle;
  static deserializeBinaryFromReader(message: T2sCloudProviderConfigGoogle, reader: jspb.BinaryReader): T2sCloudProviderConfigGoogle;
}

export namespace T2sCloudProviderConfigGoogle {
  export type AsObject = {
    speakingRate: number,
    volumeGainDb: number,
    pitch: number,
  }
}

export class SynthesizeResponse extends jspb.Message {
  getAudioUuid(): string;
  setAudioUuid(value: string): SynthesizeResponse;

  getAudio(): Uint8Array | string;
  getAudio_asU8(): Uint8Array;
  getAudio_asB64(): string;
  setAudio(value: Uint8Array | string): SynthesizeResponse;

  getGenerationTime(): number;
  setGenerationTime(value: number): SynthesizeResponse;

  getAudioLength(): number;
  setAudioLength(value: number): SynthesizeResponse;

  getText(): string;
  setText(value: string): SynthesizeResponse;

  getConfig(): RequestConfig | undefined;
  setConfig(value?: RequestConfig): SynthesizeResponse;
  hasConfig(): boolean;
  clearConfig(): SynthesizeResponse;

  getNormalizedText(): string;
  setNormalizedText(value: string): SynthesizeResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SynthesizeResponse.AsObject;
  static toObject(includeInstance: boolean, msg: SynthesizeResponse): SynthesizeResponse.AsObject;
  static serializeBinaryToWriter(message: SynthesizeResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SynthesizeResponse;
  static deserializeBinaryFromReader(message: SynthesizeResponse, reader: jspb.BinaryReader): SynthesizeResponse;
}

export namespace SynthesizeResponse {
  export type AsObject = {
    audioUuid: string,
    audio: Uint8Array | string,
    generationTime: number,
    audioLength: number,
    text: string,
    config?: RequestConfig.AsObject,
    normalizedText: string,
  }
}

export class NormalizeTextRequest extends jspb.Message {
  getT2sPipelineId(): string;
  setT2sPipelineId(value: string): NormalizeTextRequest;

  getText(): string;
  setText(value: string): NormalizeTextRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): NormalizeTextRequest.AsObject;
  static toObject(includeInstance: boolean, msg: NormalizeTextRequest): NormalizeTextRequest.AsObject;
  static serializeBinaryToWriter(message: NormalizeTextRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): NormalizeTextRequest;
  static deserializeBinaryFromReader(message: NormalizeTextRequest, reader: jspb.BinaryReader): NormalizeTextRequest;
}

export namespace NormalizeTextRequest {
  export type AsObject = {
    t2sPipelineId: string,
    text: string,
  }
}

export class NormalizeTextResponse extends jspb.Message {
  getNormalizedText(): string;
  setNormalizedText(value: string): NormalizeTextResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): NormalizeTextResponse.AsObject;
  static toObject(includeInstance: boolean, msg: NormalizeTextResponse): NormalizeTextResponse.AsObject;
  static serializeBinaryToWriter(message: NormalizeTextResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): NormalizeTextResponse;
  static deserializeBinaryFromReader(message: NormalizeTextResponse, reader: jspb.BinaryReader): NormalizeTextResponse;
}

export namespace NormalizeTextResponse {
  export type AsObject = {
    normalizedText: string,
  }
}

export class T2SGetServiceInfoResponse extends jspb.Message {
  getVersion(): string;
  setVersion(value: string): T2SGetServiceInfoResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2SGetServiceInfoResponse.AsObject;
  static toObject(includeInstance: boolean, msg: T2SGetServiceInfoResponse): T2SGetServiceInfoResponse.AsObject;
  static serializeBinaryToWriter(message: T2SGetServiceInfoResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2SGetServiceInfoResponse;
  static deserializeBinaryFromReader(message: T2SGetServiceInfoResponse, reader: jspb.BinaryReader): T2SGetServiceInfoResponse;
}

export namespace T2SGetServiceInfoResponse {
  export type AsObject = {
    version: string,
  }
}

export class ListT2sPipelinesRequest extends jspb.Message {
  getLanguagesList(): Array<string>;
  setLanguagesList(value: Array<string>): ListT2sPipelinesRequest;
  clearLanguagesList(): ListT2sPipelinesRequest;
  addLanguages(value: string, index?: number): ListT2sPipelinesRequest;

  getSpeakerSexesList(): Array<string>;
  setSpeakerSexesList(value: Array<string>): ListT2sPipelinesRequest;
  clearSpeakerSexesList(): ListT2sPipelinesRequest;
  addSpeakerSexes(value: string, index?: number): ListT2sPipelinesRequest;

  getPipelineOwnersList(): Array<string>;
  setPipelineOwnersList(value: Array<string>): ListT2sPipelinesRequest;
  clearPipelineOwnersList(): ListT2sPipelinesRequest;
  addPipelineOwners(value: string, index?: number): ListT2sPipelinesRequest;

  getSpeakerNamesList(): Array<string>;
  setSpeakerNamesList(value: Array<string>): ListT2sPipelinesRequest;
  clearSpeakerNamesList(): ListT2sPipelinesRequest;
  addSpeakerNames(value: string, index?: number): ListT2sPipelinesRequest;

  getDomainsList(): Array<string>;
  setDomainsList(value: Array<string>): ListT2sPipelinesRequest;
  clearDomainsList(): ListT2sPipelinesRequest;
  addDomains(value: string, index?: number): ListT2sPipelinesRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListT2sPipelinesRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ListT2sPipelinesRequest): ListT2sPipelinesRequest.AsObject;
  static serializeBinaryToWriter(message: ListT2sPipelinesRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListT2sPipelinesRequest;
  static deserializeBinaryFromReader(message: ListT2sPipelinesRequest, reader: jspb.BinaryReader): ListT2sPipelinesRequest;
}

export namespace ListT2sPipelinesRequest {
  export type AsObject = {
    languagesList: Array<string>,
    speakerSexesList: Array<string>,
    pipelineOwnersList: Array<string>,
    speakerNamesList: Array<string>,
    domainsList: Array<string>,
  }
}

export class ListT2sPipelinesResponse extends jspb.Message {
  getPipelinesList(): Array<Text2SpeechConfig>;
  setPipelinesList(value: Array<Text2SpeechConfig>): ListT2sPipelinesResponse;
  clearPipelinesList(): ListT2sPipelinesResponse;
  addPipelines(value?: Text2SpeechConfig, index?: number): Text2SpeechConfig;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListT2sPipelinesResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ListT2sPipelinesResponse): ListT2sPipelinesResponse.AsObject;
  static serializeBinaryToWriter(message: ListT2sPipelinesResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListT2sPipelinesResponse;
  static deserializeBinaryFromReader(message: ListT2sPipelinesResponse, reader: jspb.BinaryReader): ListT2sPipelinesResponse;
}

export namespace ListT2sPipelinesResponse {
  export type AsObject = {
    pipelinesList: Array<Text2SpeechConfig.AsObject>,
  }
}

export class ListT2sLanguagesRequest extends jspb.Message {
  getSpeakerSexesList(): Array<string>;
  setSpeakerSexesList(value: Array<string>): ListT2sLanguagesRequest;
  clearSpeakerSexesList(): ListT2sLanguagesRequest;
  addSpeakerSexes(value: string, index?: number): ListT2sLanguagesRequest;

  getPipelineOwnersList(): Array<string>;
  setPipelineOwnersList(value: Array<string>): ListT2sLanguagesRequest;
  clearPipelineOwnersList(): ListT2sLanguagesRequest;
  addPipelineOwners(value: string, index?: number): ListT2sLanguagesRequest;

  getSpeakerNamesList(): Array<string>;
  setSpeakerNamesList(value: Array<string>): ListT2sLanguagesRequest;
  clearSpeakerNamesList(): ListT2sLanguagesRequest;
  addSpeakerNames(value: string, index?: number): ListT2sLanguagesRequest;

  getDomainsList(): Array<string>;
  setDomainsList(value: Array<string>): ListT2sLanguagesRequest;
  clearDomainsList(): ListT2sLanguagesRequest;
  addDomains(value: string, index?: number): ListT2sLanguagesRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListT2sLanguagesRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ListT2sLanguagesRequest): ListT2sLanguagesRequest.AsObject;
  static serializeBinaryToWriter(message: ListT2sLanguagesRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListT2sLanguagesRequest;
  static deserializeBinaryFromReader(message: ListT2sLanguagesRequest, reader: jspb.BinaryReader): ListT2sLanguagesRequest;
}

export namespace ListT2sLanguagesRequest {
  export type AsObject = {
    speakerSexesList: Array<string>,
    pipelineOwnersList: Array<string>,
    speakerNamesList: Array<string>,
    domainsList: Array<string>,
  }
}

export class ListT2sLanguagesResponse extends jspb.Message {
  getLanguagesList(): Array<string>;
  setLanguagesList(value: Array<string>): ListT2sLanguagesResponse;
  clearLanguagesList(): ListT2sLanguagesResponse;
  addLanguages(value: string, index?: number): ListT2sLanguagesResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListT2sLanguagesResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ListT2sLanguagesResponse): ListT2sLanguagesResponse.AsObject;
  static serializeBinaryToWriter(message: ListT2sLanguagesResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListT2sLanguagesResponse;
  static deserializeBinaryFromReader(message: ListT2sLanguagesResponse, reader: jspb.BinaryReader): ListT2sLanguagesResponse;
}

export namespace ListT2sLanguagesResponse {
  export type AsObject = {
    languagesList: Array<string>,
  }
}

export class ListT2sDomainsRequest extends jspb.Message {
  getSpeakerSexesList(): Array<string>;
  setSpeakerSexesList(value: Array<string>): ListT2sDomainsRequest;
  clearSpeakerSexesList(): ListT2sDomainsRequest;
  addSpeakerSexes(value: string, index?: number): ListT2sDomainsRequest;

  getPipelineOwnersList(): Array<string>;
  setPipelineOwnersList(value: Array<string>): ListT2sDomainsRequest;
  clearPipelineOwnersList(): ListT2sDomainsRequest;
  addPipelineOwners(value: string, index?: number): ListT2sDomainsRequest;

  getSpeakerNamesList(): Array<string>;
  setSpeakerNamesList(value: Array<string>): ListT2sDomainsRequest;
  clearSpeakerNamesList(): ListT2sDomainsRequest;
  addSpeakerNames(value: string, index?: number): ListT2sDomainsRequest;

  getLanguagesList(): Array<string>;
  setLanguagesList(value: Array<string>): ListT2sDomainsRequest;
  clearLanguagesList(): ListT2sDomainsRequest;
  addLanguages(value: string, index?: number): ListT2sDomainsRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListT2sDomainsRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ListT2sDomainsRequest): ListT2sDomainsRequest.AsObject;
  static serializeBinaryToWriter(message: ListT2sDomainsRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListT2sDomainsRequest;
  static deserializeBinaryFromReader(message: ListT2sDomainsRequest, reader: jspb.BinaryReader): ListT2sDomainsRequest;
}

export namespace ListT2sDomainsRequest {
  export type AsObject = {
    speakerSexesList: Array<string>,
    pipelineOwnersList: Array<string>,
    speakerNamesList: Array<string>,
    languagesList: Array<string>,
  }
}

export class ListT2sDomainsResponse extends jspb.Message {
  getDomainsList(): Array<string>;
  setDomainsList(value: Array<string>): ListT2sDomainsResponse;
  clearDomainsList(): ListT2sDomainsResponse;
  addDomains(value: string, index?: number): ListT2sDomainsResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListT2sDomainsResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ListT2sDomainsResponse): ListT2sDomainsResponse.AsObject;
  static serializeBinaryToWriter(message: ListT2sDomainsResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListT2sDomainsResponse;
  static deserializeBinaryFromReader(message: ListT2sDomainsResponse, reader: jspb.BinaryReader): ListT2sDomainsResponse;
}

export namespace ListT2sDomainsResponse {
  export type AsObject = {
    domainsList: Array<string>,
  }
}

export class T2sPipelineId extends jspb.Message {
  getId(): string;
  setId(value: string): T2sPipelineId;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2sPipelineId.AsObject;
  static toObject(includeInstance: boolean, msg: T2sPipelineId): T2sPipelineId.AsObject;
  static serializeBinaryToWriter(message: T2sPipelineId, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2sPipelineId;
  static deserializeBinaryFromReader(message: T2sPipelineId, reader: jspb.BinaryReader): T2sPipelineId;
}

export namespace T2sPipelineId {
  export type AsObject = {
    id: string,
  }
}

export class Text2SpeechConfig extends jspb.Message {
  getId(): string;
  setId(value: string): Text2SpeechConfig;

  getDescription(): T2SDescription | undefined;
  setDescription(value?: T2SDescription): Text2SpeechConfig;
  hasDescription(): boolean;
  clearDescription(): Text2SpeechConfig;

  getActive(): boolean;
  setActive(value: boolean): Text2SpeechConfig;

  getInference(): T2SInference | undefined;
  setInference(value?: T2SInference): Text2SpeechConfig;
  hasInference(): boolean;
  clearInference(): Text2SpeechConfig;

  getNormalization(): T2SNormalization | undefined;
  setNormalization(value?: T2SNormalization): Text2SpeechConfig;
  hasNormalization(): boolean;
  clearNormalization(): Text2SpeechConfig;

  getPostprocessing(): Postprocessing | undefined;
  setPostprocessing(value?: Postprocessing): Text2SpeechConfig;
  hasPostprocessing(): boolean;
  clearPostprocessing(): Text2SpeechConfig;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Text2SpeechConfig.AsObject;
  static toObject(includeInstance: boolean, msg: Text2SpeechConfig): Text2SpeechConfig.AsObject;
  static serializeBinaryToWriter(message: Text2SpeechConfig, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Text2SpeechConfig;
  static deserializeBinaryFromReader(message: Text2SpeechConfig, reader: jspb.BinaryReader): Text2SpeechConfig;
}

export namespace Text2SpeechConfig {
  export type AsObject = {
    id: string,
    description?: T2SDescription.AsObject,
    active: boolean,
    inference?: T2SInference.AsObject,
    normalization?: T2SNormalization.AsObject,
    postprocessing?: Postprocessing.AsObject,
  }
}

export class T2SDescription extends jspb.Message {
  getLanguage(): string;
  setLanguage(value: string): T2SDescription;

  getSpeakerSex(): string;
  setSpeakerSex(value: string): T2SDescription;

  getPipelineOwner(): string;
  setPipelineOwner(value: string): T2SDescription;

  getComments(): string;
  setComments(value: string): T2SDescription;

  getSpeakerName(): string;
  setSpeakerName(value: string): T2SDescription;

  getDomain(): string;
  setDomain(value: string): T2SDescription;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2SDescription.AsObject;
  static toObject(includeInstance: boolean, msg: T2SDescription): T2SDescription.AsObject;
  static serializeBinaryToWriter(message: T2SDescription, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2SDescription;
  static deserializeBinaryFromReader(message: T2SDescription, reader: jspb.BinaryReader): T2SDescription;
}

export namespace T2SDescription {
  export type AsObject = {
    language: string,
    speakerSex: string,
    pipelineOwner: string,
    comments: string,
    speakerName: string,
    domain: string,
  }
}

export class T2SInference extends jspb.Message {
  getType(): string;
  setType(value: string): T2SInference;

  getCompositeInference(): CompositeInference | undefined;
  setCompositeInference(value?: CompositeInference): T2SInference;
  hasCompositeInference(): boolean;
  clearCompositeInference(): T2SInference;

  getSingleInference(): SingleInference | undefined;
  setSingleInference(value?: SingleInference): T2SInference;
  hasSingleInference(): boolean;
  clearSingleInference(): T2SInference;

  getCaching(): Caching | undefined;
  setCaching(value?: Caching): T2SInference;
  hasCaching(): boolean;
  clearCaching(): T2SInference;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2SInference.AsObject;
  static toObject(includeInstance: boolean, msg: T2SInference): T2SInference.AsObject;
  static serializeBinaryToWriter(message: T2SInference, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2SInference;
  static deserializeBinaryFromReader(message: T2SInference, reader: jspb.BinaryReader): T2SInference;
}

export namespace T2SInference {
  export type AsObject = {
    type: string,
    compositeInference?: CompositeInference.AsObject,
    singleInference?: SingleInference.AsObject,
    caching?: Caching.AsObject,
  }
}

export class CompositeInference extends jspb.Message {
  getText2mel(): Text2Mel | undefined;
  setText2mel(value?: Text2Mel): CompositeInference;
  hasText2mel(): boolean;
  clearText2mel(): CompositeInference;

  getMel2audio(): Mel2Audio | undefined;
  setMel2audio(value?: Mel2Audio): CompositeInference;
  hasMel2audio(): boolean;
  clearMel2audio(): CompositeInference;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CompositeInference.AsObject;
  static toObject(includeInstance: boolean, msg: CompositeInference): CompositeInference.AsObject;
  static serializeBinaryToWriter(message: CompositeInference, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CompositeInference;
  static deserializeBinaryFromReader(message: CompositeInference, reader: jspb.BinaryReader): CompositeInference;
}

export namespace CompositeInference {
  export type AsObject = {
    text2mel?: Text2Mel.AsObject,
    mel2audio?: Mel2Audio.AsObject,
  }
}

export class SingleInference extends jspb.Message {
  getText2audio(): Text2Audio | undefined;
  setText2audio(value?: Text2Audio): SingleInference;
  hasText2audio(): boolean;
  clearText2audio(): SingleInference;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SingleInference.AsObject;
  static toObject(includeInstance: boolean, msg: SingleInference): SingleInference.AsObject;
  static serializeBinaryToWriter(message: SingleInference, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SingleInference;
  static deserializeBinaryFromReader(message: SingleInference, reader: jspb.BinaryReader): SingleInference;
}

export namespace SingleInference {
  export type AsObject = {
    text2audio?: Text2Audio.AsObject,
  }
}

export class Text2Mel extends jspb.Message {
  getType(): string;
  setType(value: string): Text2Mel;

  getGlowTts(): GlowTTS | undefined;
  setGlowTts(value?: GlowTTS): Text2Mel;
  hasGlowTts(): boolean;
  clearGlowTts(): Text2Mel;

  getGlowTtsTriton(): GlowTTSTriton | undefined;
  setGlowTtsTriton(value?: GlowTTSTriton): Text2Mel;
  hasGlowTtsTriton(): boolean;
  clearGlowTtsTriton(): Text2Mel;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Text2Mel.AsObject;
  static toObject(includeInstance: boolean, msg: Text2Mel): Text2Mel.AsObject;
  static serializeBinaryToWriter(message: Text2Mel, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Text2Mel;
  static deserializeBinaryFromReader(message: Text2Mel, reader: jspb.BinaryReader): Text2Mel;
}

export namespace Text2Mel {
  export type AsObject = {
    type: string,
    glowTts?: GlowTTS.AsObject,
    glowTtsTriton?: GlowTTSTriton.AsObject,
  }
}

export class Text2Audio extends jspb.Message {
  getType(): string;
  setType(value: string): Text2Audio;

  getVits(): Vits | undefined;
  setVits(value?: Vits): Text2Audio;
  hasVits(): boolean;
  clearVits(): Text2Audio;

  getVitsTriton(): VitsTriton | undefined;
  setVitsTriton(value?: VitsTriton): Text2Audio;
  hasVitsTriton(): boolean;
  clearVitsTriton(): Text2Audio;

  getT2sCloudServiceElevenlabs(): T2sCloudServiceElevenLabs | undefined;
  setT2sCloudServiceElevenlabs(value?: T2sCloudServiceElevenLabs): Text2Audio;
  hasT2sCloudServiceElevenlabs(): boolean;
  clearT2sCloudServiceElevenlabs(): Text2Audio;

  getT2sCloudServiceAmazon(): T2sCloudServiceAmazon | undefined;
  setT2sCloudServiceAmazon(value?: T2sCloudServiceAmazon): Text2Audio;
  hasT2sCloudServiceAmazon(): boolean;
  clearT2sCloudServiceAmazon(): Text2Audio;

  getT2sCloudServiceGoogle(): T2sCloudServiceGoogle | undefined;
  setT2sCloudServiceGoogle(value?: T2sCloudServiceGoogle): Text2Audio;
  hasT2sCloudServiceGoogle(): boolean;
  clearT2sCloudServiceGoogle(): Text2Audio;

  getT2sCloudServiceMicrosoft(): T2sCloudServiceMicrosoft | undefined;
  setT2sCloudServiceMicrosoft(value?: T2sCloudServiceMicrosoft): Text2Audio;
  hasT2sCloudServiceMicrosoft(): boolean;
  clearT2sCloudServiceMicrosoft(): Text2Audio;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Text2Audio.AsObject;
  static toObject(includeInstance: boolean, msg: Text2Audio): Text2Audio.AsObject;
  static serializeBinaryToWriter(message: Text2Audio, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Text2Audio;
  static deserializeBinaryFromReader(message: Text2Audio, reader: jspb.BinaryReader): Text2Audio;
}

export namespace Text2Audio {
  export type AsObject = {
    type: string,
    vits?: Vits.AsObject,
    vitsTriton?: VitsTriton.AsObject,
    t2sCloudServiceElevenlabs?: T2sCloudServiceElevenLabs.AsObject,
    t2sCloudServiceAmazon?: T2sCloudServiceAmazon.AsObject,
    t2sCloudServiceGoogle?: T2sCloudServiceGoogle.AsObject,
    t2sCloudServiceMicrosoft?: T2sCloudServiceMicrosoft.AsObject,
  }
}

export class GlowTTS extends jspb.Message {
  getBatchSize(): number;
  setBatchSize(value: number): GlowTTS;

  getUseGpu(): boolean;
  setUseGpu(value: boolean): GlowTTS;

  getLengthScale(): number;
  setLengthScale(value: number): GlowTTS;

  getNoiseScale(): number;
  setNoiseScale(value: number): GlowTTS;

  getPath(): string;
  setPath(value: string): GlowTTS;

  getCleanersList(): Array<string>;
  setCleanersList(value: Array<string>): GlowTTS;
  clearCleanersList(): GlowTTS;
  addCleaners(value: string, index?: number): GlowTTS;

  getParamConfigPath(): string;
  setParamConfigPath(value: string): GlowTTS;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GlowTTS.AsObject;
  static toObject(includeInstance: boolean, msg: GlowTTS): GlowTTS.AsObject;
  static serializeBinaryToWriter(message: GlowTTS, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GlowTTS;
  static deserializeBinaryFromReader(message: GlowTTS, reader: jspb.BinaryReader): GlowTTS;
}

export namespace GlowTTS {
  export type AsObject = {
    batchSize: number,
    useGpu: boolean,
    lengthScale: number,
    noiseScale: number,
    path: string,
    cleanersList: Array<string>,
    paramConfigPath: string,
  }
}

export class GlowTTSTriton extends jspb.Message {
  getBatchSize(): number;
  setBatchSize(value: number): GlowTTSTriton;

  getLengthScale(): number;
  setLengthScale(value: number): GlowTTSTriton;

  getNoiseScale(): number;
  setNoiseScale(value: number): GlowTTSTriton;

  getCleanersList(): Array<string>;
  setCleanersList(value: Array<string>): GlowTTSTriton;
  clearCleanersList(): GlowTTSTriton;
  addCleaners(value: string, index?: number): GlowTTSTriton;

  getMaxTextLength(): number;
  setMaxTextLength(value: number): GlowTTSTriton;

  getParamConfigPath(): string;
  setParamConfigPath(value: string): GlowTTSTriton;

  getTritonModelName(): string;
  setTritonModelName(value: string): GlowTTSTriton;

  getTritonServerHost(): string;
  setTritonServerHost(value: string): GlowTTSTriton;

  getTritonServerPort(): number;
  setTritonServerPort(value: number): GlowTTSTriton;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GlowTTSTriton.AsObject;
  static toObject(includeInstance: boolean, msg: GlowTTSTriton): GlowTTSTriton.AsObject;
  static serializeBinaryToWriter(message: GlowTTSTriton, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GlowTTSTriton;
  static deserializeBinaryFromReader(message: GlowTTSTriton, reader: jspb.BinaryReader): GlowTTSTriton;
}

export namespace GlowTTSTriton {
  export type AsObject = {
    batchSize: number,
    lengthScale: number,
    noiseScale: number,
    cleanersList: Array<string>,
    maxTextLength: number,
    paramConfigPath: string,
    tritonModelName: string,
    tritonServerHost: string,
    tritonServerPort: number,
  }
}

export class Vits extends jspb.Message {
  getBatchSize(): number;
  setBatchSize(value: number): Vits;

  getUseGpu(): boolean;
  setUseGpu(value: boolean): Vits;

  getLengthScale(): number;
  setLengthScale(value: number): Vits;

  getNoiseScale(): number;
  setNoiseScale(value: number): Vits;

  getPath(): string;
  setPath(value: string): Vits;

  getCleanersList(): Array<string>;
  setCleanersList(value: Array<string>): Vits;
  clearCleanersList(): Vits;
  addCleaners(value: string, index?: number): Vits;

  getParamConfigPath(): string;
  setParamConfigPath(value: string): Vits;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Vits.AsObject;
  static toObject(includeInstance: boolean, msg: Vits): Vits.AsObject;
  static serializeBinaryToWriter(message: Vits, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Vits;
  static deserializeBinaryFromReader(message: Vits, reader: jspb.BinaryReader): Vits;
}

export namespace Vits {
  export type AsObject = {
    batchSize: number,
    useGpu: boolean,
    lengthScale: number,
    noiseScale: number,
    path: string,
    cleanersList: Array<string>,
    paramConfigPath: string,
  }
}

export class VitsTriton extends jspb.Message {
  getBatchSize(): number;
  setBatchSize(value: number): VitsTriton;

  getLengthScale(): number;
  setLengthScale(value: number): VitsTriton;

  getNoiseScale(): number;
  setNoiseScale(value: number): VitsTriton;

  getCleanersList(): Array<string>;
  setCleanersList(value: Array<string>): VitsTriton;
  clearCleanersList(): VitsTriton;
  addCleaners(value: string, index?: number): VitsTriton;

  getMaxTextLength(): number;
  setMaxTextLength(value: number): VitsTriton;

  getParamConfigPath(): string;
  setParamConfigPath(value: string): VitsTriton;

  getTritonModelName(): string;
  setTritonModelName(value: string): VitsTriton;

  getTritonServerHost(): string;
  setTritonServerHost(value: string): VitsTriton;

  getTritonServerPort(): number;
  setTritonServerPort(value: number): VitsTriton;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): VitsTriton.AsObject;
  static toObject(includeInstance: boolean, msg: VitsTriton): VitsTriton.AsObject;
  static serializeBinaryToWriter(message: VitsTriton, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): VitsTriton;
  static deserializeBinaryFromReader(message: VitsTriton, reader: jspb.BinaryReader): VitsTriton;
}

export namespace VitsTriton {
  export type AsObject = {
    batchSize: number,
    lengthScale: number,
    noiseScale: number,
    cleanersList: Array<string>,
    maxTextLength: number,
    paramConfigPath: string,
    tritonModelName: string,
    tritonServerHost: string,
    tritonServerPort: number,
  }
}

export class T2sCloudServiceElevenLabs extends jspb.Message {
  getLanguageCode(): string;
  setLanguageCode(value: string): T2sCloudServiceElevenLabs;

  getModelId(): string;
  setModelId(value: string): T2sCloudServiceElevenLabs;

  getVoiceId(): string;
  setVoiceId(value: string): T2sCloudServiceElevenLabs;

  getVoiceSettings(): VoiceSettings | undefined;
  setVoiceSettings(value?: VoiceSettings): T2sCloudServiceElevenLabs;
  hasVoiceSettings(): boolean;
  clearVoiceSettings(): T2sCloudServiceElevenLabs;

  getApplyTextNormalization(): string;
  setApplyTextNormalization(value: string): T2sCloudServiceElevenLabs;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2sCloudServiceElevenLabs.AsObject;
  static toObject(includeInstance: boolean, msg: T2sCloudServiceElevenLabs): T2sCloudServiceElevenLabs.AsObject;
  static serializeBinaryToWriter(message: T2sCloudServiceElevenLabs, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2sCloudServiceElevenLabs;
  static deserializeBinaryFromReader(message: T2sCloudServiceElevenLabs, reader: jspb.BinaryReader): T2sCloudServiceElevenLabs;
}

export namespace T2sCloudServiceElevenLabs {
  export type AsObject = {
    languageCode: string,
    modelId: string,
    voiceId: string,
    voiceSettings?: VoiceSettings.AsObject,
    applyTextNormalization: string,
  }
}

export class VoiceSettings extends jspb.Message {
  getStability(): number;
  setStability(value: number): VoiceSettings;

  getSimilarityBoost(): number;
  setSimilarityBoost(value: number): VoiceSettings;

  getStyle(): number;
  setStyle(value: number): VoiceSettings;

  getUseSpeakerBoost(): boolean;
  setUseSpeakerBoost(value: boolean): VoiceSettings;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): VoiceSettings.AsObject;
  static toObject(includeInstance: boolean, msg: VoiceSettings): VoiceSettings.AsObject;
  static serializeBinaryToWriter(message: VoiceSettings, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): VoiceSettings;
  static deserializeBinaryFromReader(message: VoiceSettings, reader: jspb.BinaryReader): VoiceSettings;
}

export namespace VoiceSettings {
  export type AsObject = {
    stability: number,
    similarityBoost: number,
    style: number,
    useSpeakerBoost: boolean,
  }
}

export class T2sCloudServiceAmazon extends jspb.Message {
  getVoiceId(): string;
  setVoiceId(value: string): T2sCloudServiceAmazon;

  getModelId(): string;
  setModelId(value: string): T2sCloudServiceAmazon;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2sCloudServiceAmazon.AsObject;
  static toObject(includeInstance: boolean, msg: T2sCloudServiceAmazon): T2sCloudServiceAmazon.AsObject;
  static serializeBinaryToWriter(message: T2sCloudServiceAmazon, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2sCloudServiceAmazon;
  static deserializeBinaryFromReader(message: T2sCloudServiceAmazon, reader: jspb.BinaryReader): T2sCloudServiceAmazon;
}

export namespace T2sCloudServiceAmazon {
  export type AsObject = {
    voiceId: string,
    modelId: string,
  }
}

export class T2sCloudServiceGoogle extends jspb.Message {
  getVoiceId(): string;
  setVoiceId(value: string): T2sCloudServiceGoogle;

  getSpeakingRate(): number;
  setSpeakingRate(value: number): T2sCloudServiceGoogle;

  getVolumeGainDb(): number;
  setVolumeGainDb(value: number): T2sCloudServiceGoogle;

  getPitch(): number;
  setPitch(value: number): T2sCloudServiceGoogle;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2sCloudServiceGoogle.AsObject;
  static toObject(includeInstance: boolean, msg: T2sCloudServiceGoogle): T2sCloudServiceGoogle.AsObject;
  static serializeBinaryToWriter(message: T2sCloudServiceGoogle, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2sCloudServiceGoogle;
  static deserializeBinaryFromReader(message: T2sCloudServiceGoogle, reader: jspb.BinaryReader): T2sCloudServiceGoogle;
}

export namespace T2sCloudServiceGoogle {
  export type AsObject = {
    voiceId: string,
    speakingRate: number,
    volumeGainDb: number,
    pitch: number,
  }
}

export class T2sCloudServiceMicrosoft extends jspb.Message {
  getVoiceId(): string;
  setVoiceId(value: string): T2sCloudServiceMicrosoft;

  getUseDefaultSpeaker(): boolean;
  setUseDefaultSpeaker(value: boolean): T2sCloudServiceMicrosoft;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): T2sCloudServiceMicrosoft.AsObject;
  static toObject(includeInstance: boolean, msg: T2sCloudServiceMicrosoft): T2sCloudServiceMicrosoft.AsObject;
  static serializeBinaryToWriter(message: T2sCloudServiceMicrosoft, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): T2sCloudServiceMicrosoft;
  static deserializeBinaryFromReader(message: T2sCloudServiceMicrosoft, reader: jspb.BinaryReader): T2sCloudServiceMicrosoft;
}

export namespace T2sCloudServiceMicrosoft {
  export type AsObject = {
    voiceId: string,
    useDefaultSpeaker: boolean,
  }
}

export class Mel2Audio extends jspb.Message {
  getType(): string;
  setType(value: string): Mel2Audio;

  getMbMelganTriton(): MbMelganTriton | undefined;
  setMbMelganTriton(value?: MbMelganTriton): Mel2Audio;
  hasMbMelganTriton(): boolean;
  clearMbMelganTriton(): Mel2Audio;

  getHifiGan(): HiFiGan | undefined;
  setHifiGan(value?: HiFiGan): Mel2Audio;
  hasHifiGan(): boolean;
  clearHifiGan(): Mel2Audio;

  getHifiGanTriton(): HiFiGanTriton | undefined;
  setHifiGanTriton(value?: HiFiGanTriton): Mel2Audio;
  hasHifiGanTriton(): boolean;
  clearHifiGanTriton(): Mel2Audio;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Mel2Audio.AsObject;
  static toObject(includeInstance: boolean, msg: Mel2Audio): Mel2Audio.AsObject;
  static serializeBinaryToWriter(message: Mel2Audio, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Mel2Audio;
  static deserializeBinaryFromReader(message: Mel2Audio, reader: jspb.BinaryReader): Mel2Audio;
}

export namespace Mel2Audio {
  export type AsObject = {
    type: string,
    mbMelganTriton?: MbMelganTriton.AsObject,
    hifiGan?: HiFiGan.AsObject,
    hifiGanTriton?: HiFiGanTriton.AsObject,
  }
}

export class HiFiGan extends jspb.Message {
  getUseGpu(): boolean;
  setUseGpu(value: boolean): HiFiGan;

  getBatchSize(): number;
  setBatchSize(value: number): HiFiGan;

  getConfigPath(): string;
  setConfigPath(value: string): HiFiGan;

  getModelPath(): string;
  setModelPath(value: string): HiFiGan;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): HiFiGan.AsObject;
  static toObject(includeInstance: boolean, msg: HiFiGan): HiFiGan.AsObject;
  static serializeBinaryToWriter(message: HiFiGan, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): HiFiGan;
  static deserializeBinaryFromReader(message: HiFiGan, reader: jspb.BinaryReader): HiFiGan;
}

export namespace HiFiGan {
  export type AsObject = {
    useGpu: boolean,
    batchSize: number,
    configPath: string,
    modelPath: string,
  }
}

export class HiFiGanTriton extends jspb.Message {
  getConfigPath(): string;
  setConfigPath(value: string): HiFiGanTriton;

  getTritonModelName(): string;
  setTritonModelName(value: string): HiFiGanTriton;

  getTritonServerHost(): string;
  setTritonServerHost(value: string): HiFiGanTriton;

  getTritonServerPort(): number;
  setTritonServerPort(value: number): HiFiGanTriton;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): HiFiGanTriton.AsObject;
  static toObject(includeInstance: boolean, msg: HiFiGanTriton): HiFiGanTriton.AsObject;
  static serializeBinaryToWriter(message: HiFiGanTriton, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): HiFiGanTriton;
  static deserializeBinaryFromReader(message: HiFiGanTriton, reader: jspb.BinaryReader): HiFiGanTriton;
}

export namespace HiFiGanTriton {
  export type AsObject = {
    configPath: string,
    tritonModelName: string,
    tritonServerHost: string,
    tritonServerPort: number,
  }
}

export class MbMelganTriton extends jspb.Message {
  getConfigPath(): string;
  setConfigPath(value: string): MbMelganTriton;

  getStatsPath(): string;
  setStatsPath(value: string): MbMelganTriton;

  getTritonModelName(): string;
  setTritonModelName(value: string): MbMelganTriton;

  getTritonServerHost(): string;
  setTritonServerHost(value: string): MbMelganTriton;

  getTritonServerPort(): number;
  setTritonServerPort(value: number): MbMelganTriton;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): MbMelganTriton.AsObject;
  static toObject(includeInstance: boolean, msg: MbMelganTriton): MbMelganTriton.AsObject;
  static serializeBinaryToWriter(message: MbMelganTriton, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): MbMelganTriton;
  static deserializeBinaryFromReader(message: MbMelganTriton, reader: jspb.BinaryReader): MbMelganTriton;
}

export namespace MbMelganTriton {
  export type AsObject = {
    configPath: string,
    statsPath: string,
    tritonModelName: string,
    tritonServerHost: string,
    tritonServerPort: number,
  }
}

export class Caching extends jspb.Message {
  getActive(): boolean;
  setActive(value: boolean): Caching;

  getMemoryCacheMaxSize(): number;
  setMemoryCacheMaxSize(value: number): Caching;

  getSamplingRate(): number;
  setSamplingRate(value: number): Caching;

  getLoadCache(): boolean;
  setLoadCache(value: boolean): Caching;

  getSaveCache(): boolean;
  setSaveCache(value: boolean): Caching;

  getCacheSaveDir(): string;
  setCacheSaveDir(value: string): Caching;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Caching.AsObject;
  static toObject(includeInstance: boolean, msg: Caching): Caching.AsObject;
  static serializeBinaryToWriter(message: Caching, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Caching;
  static deserializeBinaryFromReader(message: Caching, reader: jspb.BinaryReader): Caching;
}

export namespace Caching {
  export type AsObject = {
    active: boolean,
    memoryCacheMaxSize: number,
    samplingRate: number,
    loadCache: boolean,
    saveCache: boolean,
    cacheSaveDir: string,
  }
}

export class T2SNormalization extends jspb.Message {
  getLanguage(): string;
  setLanguage(value: string): T2SNormalization;

  getPipelineList(): Array<string>;
  setPipelineList(value: Array<string>): T2SNormalization;
  clearPipelineList(): T2SNormalization;
  addPipeline(value: string, index?: number): T2SNormalization;

  getCustomPhonemizerId(): string;
  setCustomPhonemizerId(value: string): T2SNormalization;

  getCustomLengthScales(): T2SCustomLengthScales | undefined;
  setCustomLengthScales(value?: T2SCustomLengthScales): T2SNormalization;
  hasCustomLengthScales(): boolean;
  clearCustomLengthScales(): T2SNormalization;

  getArpabe