@ondewo/s2t-client-typescript 5.7.0 → 7.0.0

package/api/ondewo/s2t/speech-to-text_pb.d.ts

@@ -1,1517 +1,2621 @@
-import * as jspb from 'google-protobuf';
+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"
 
-import * as google_protobuf_empty_pb from 'google-protobuf/google/protobuf/empty_pb';
 
 export class TranscribeRequestConfig extends jspb.Message {
-	getS2tPipelineId(): string;
-	setS2tPipelineId(value: string): TranscribeRequestConfig;
+  getS2tPipelineId(): string;
+  setS2tPipelineId(value: string): TranscribeRequestConfig;
+
+  getDecoding(): Decoding;
+  setDecoding(value: Decoding): TranscribeRequestConfig;
 
-	getDecoding(): Decoding;
-	setDecoding(value: Decoding): TranscribeRequestConfig;
+  getLanguageModelName(): string;
+  setLanguageModelName(value: string): TranscribeRequestConfig;
 
-	getLanguageModelName(): string;
-	setLanguageModelName(value: string): TranscribeRequestConfig;
+  getPostProcessing(): PostProcessingOptions | undefined;
+  setPostProcessing(value?: PostProcessingOptions): TranscribeRequestConfig;
+  hasPostProcessing(): boolean;
+  clearPostProcessing(): TranscribeRequestConfig;
 
-	getPostProcessing(): PostProcessingOptions | undefined;
-	setPostProcessing(value?: PostProcessingOptions): TranscribeRequestConfig;
-	hasPostProcessing(): boolean;
-	clearPostProcessing(): TranscribeRequestConfig;
+  getUtteranceDetection(): UtteranceDetectionOptions | undefined;
+  setUtteranceDetection(value?: UtteranceDetectionOptions): TranscribeRequestConfig;
+  hasUtteranceDetection(): boolean;
+  clearUtteranceDetection(): TranscribeRequestConfig;
 
-	getUtteranceDetection(): UtteranceDetectionOptions | undefined;
-	setUtteranceDetection(value?: UtteranceDetectionOptions): TranscribeRequestConfig;
-	hasUtteranceDetection(): boolean;
-	clearUtteranceDetection(): TranscribeRequestConfig;
+  getPyannote(): Pyannote | undefined;
+  setPyannote(value?: Pyannote): TranscribeRequestConfig;
+  hasPyannote(): boolean;
+  clearPyannote(): TranscribeRequestConfig;
 
-	getPyannote(): Pyannote | undefined;
-	setPyannote(value?: Pyannote): TranscribeRequestConfig;
-	hasPyannote(): boolean;
-	clearPyannote(): TranscribeRequestConfig;
+  getReturnOptions(): TranscriptionReturnOptions | undefined;
+  setReturnOptions(value?: TranscriptionReturnOptions): TranscribeRequestConfig;
+  hasReturnOptions(): boolean;
+  clearReturnOptions(): TranscribeRequestConfig;
 
-	getReturnOptions(): TranscriptionReturnOptions | undefined;
-	setReturnOptions(value?: TranscriptionReturnOptions): TranscribeRequestConfig;
-	hasReturnOptions(): boolean;
-	clearReturnOptions(): TranscribeRequestConfig;
+  getLanguage(): string;
+  setLanguage(value: string): TranscribeRequestConfig;
+  hasLanguage(): boolean;
+  clearLanguage(): TranscribeRequestConfig;
 
-	getLanguage(): string;
-	setLanguage(value: string): TranscribeRequestConfig;
-	hasLanguage(): boolean;
-	clearLanguage(): TranscribeRequestConfig;
+  getTask(): string;
+  setTask(value: string): TranscribeRequestConfig;
+  hasTask(): boolean;
+  clearTask(): TranscribeRequestConfig;
 
-	getTask(): string;
-	setTask(value: string): TranscribeRequestConfig;
-	hasTask(): boolean;
-	clearTask(): TranscribeRequestConfig;
+  getS2tServiceConfig(): google_protobuf_struct_pb.Struct | undefined;
+  setS2tServiceConfig(value?: google_protobuf_struct_pb.Struct): TranscribeRequestConfig;
+  hasS2tServiceConfig(): boolean;
+  clearS2tServiceConfig(): TranscribeRequestConfig;
 
-	getOneofLanguageModelNameCase(): TranscribeRequestConfig.OneofLanguageModelNameCase;
+  getS2tCloudProviderConfig(): S2tCloudProviderConfig | undefined;
+  setS2tCloudProviderConfig(value?: S2tCloudProviderConfig): TranscribeRequestConfig;
+  hasS2tCloudProviderConfig(): boolean;
+  clearS2tCloudProviderConfig(): TranscribeRequestConfig;
 
-	getOneofPostProcessingCase(): TranscribeRequestConfig.OneofPostProcessingCase;
+  getOneofLanguageModelNameCase(): TranscribeRequestConfig.OneofLanguageModelNameCase;
 
-	getOneofUtteranceDetectionCase(): TranscribeRequestConfig.OneofUtteranceDetectionCase;
+  getOneofPostProcessingCase(): TranscribeRequestConfig.OneofPostProcessingCase;
 
-	getVoiceActivityDetectionCase(): TranscribeRequestConfig.VoiceActivityDetectionCase;
+  getOneofUtteranceDetectionCase(): TranscribeRequestConfig.OneofUtteranceDetectionCase;
 
-	getOneofReturnOptionsCase(): TranscribeRequestConfig.OneofReturnOptionsCase;
+  getVoiceActivityDetectionCase(): TranscribeRequestConfig.VoiceActivityDetectionCase;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): TranscribeRequestConfig.AsObject;
-	static toObject(includeInstance: boolean, msg: TranscribeRequestConfig): TranscribeRequestConfig.AsObject;
-	static serializeBinaryToWriter(message: TranscribeRequestConfig, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): TranscribeRequestConfig;
-	static deserializeBinaryFromReader(
-		message: TranscribeRequestConfig,
-		reader: jspb.BinaryReader
-	): TranscribeRequestConfig;
+  getOneofReturnOptionsCase(): TranscribeRequestConfig.OneofReturnOptionsCase;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TranscribeRequestConfig.AsObject;
+  static toObject(includeInstance: boolean, msg: TranscribeRequestConfig): TranscribeRequestConfig.AsObject;
+  static serializeBinaryToWriter(message: TranscribeRequestConfig, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TranscribeRequestConfig;
+  static deserializeBinaryFromReader(message: TranscribeRequestConfig, reader: jspb.BinaryReader): TranscribeRequestConfig;
 }
 
 export namespace TranscribeRequestConfig {
-	export type AsObject = {
-		s2tPipelineId: string;
-		decoding: Decoding;
-		languageModelName: string;
-		postProcessing?: PostProcessingOptions.AsObject;
-		utteranceDetection?: UtteranceDetectionOptions.AsObject;
-		pyannote?: Pyannote.AsObject;
-		returnOptions?: TranscriptionReturnOptions.AsObject;
-		language?: string;
-		task?: string;
-	};
-
-	export enum OneofLanguageModelNameCase {
-		ONEOF_LANGUAGE_MODEL_NAME_NOT_SET = 0,
-		LANGUAGE_MODEL_NAME = 3
-	}
-
-	export enum OneofPostProcessingCase {
-		ONEOF_POST_PROCESSING_NOT_SET = 0,
-		POST_PROCESSING = 4
-	}
-
-	export enum OneofUtteranceDetectionCase {
-		ONEOF_UTTERANCE_DETECTION_NOT_SET = 0,
-		UTTERANCE_DETECTION = 5
-	}
-
-	export enum VoiceActivityDetectionCase {
-		VOICE_ACTIVITY_DETECTION_NOT_SET = 0,
-		PYANNOTE = 6
-	}
-
-	export enum OneofReturnOptionsCase {
-		ONEOF_RETURN_OPTIONS_NOT_SET = 0,
-		RETURN_OPTIONS = 8
-	}
-
-	export enum LanguageCase {
-		_LANGUAGE_NOT_SET = 0,
-		LANGUAGE = 9
-	}
-
-	export enum TaskCase {
-		_TASK_NOT_SET = 0,
-		TASK = 10
-	}
+  export type AsObject = {
+    s2tPipelineId: string,
+    decoding: Decoding,
+    languageModelName: string,
+    postProcessing?: PostProcessingOptions.AsObject,
+    utteranceDetection?: UtteranceDetectionOptions.AsObject,
+    pyannote?: Pyannote.AsObject,
+    returnOptions?: TranscriptionReturnOptions.AsObject,
+    language?: string,
+    task?: string,
+    s2tServiceConfig?: google_protobuf_struct_pb.Struct.AsObject,
+    s2tCloudProviderConfig?: S2tCloudProviderConfig.AsObject,
+  }
+
+  export enum OneofLanguageModelNameCase { 
+    ONEOF_LANGUAGE_MODEL_NAME_NOT_SET = 0,
+    LANGUAGE_MODEL_NAME = 3,
+  }
+
+  export enum OneofPostProcessingCase { 
+    ONEOF_POST_PROCESSING_NOT_SET = 0,
+    POST_PROCESSING = 4,
+  }
+
+  export enum OneofUtteranceDetectionCase { 
+    ONEOF_UTTERANCE_DETECTION_NOT_SET = 0,
+    UTTERANCE_DETECTION = 5,
+  }
+
+  export enum VoiceActivityDetectionCase { 
+    VOICE_ACTIVITY_DETECTION_NOT_SET = 0,
+    PYANNOTE = 6,
+  }
+
+  export enum OneofReturnOptionsCase { 
+    ONEOF_RETURN_OPTIONS_NOT_SET = 0,
+    RETURN_OPTIONS = 8,
+  }
+
+  export enum LanguageCase { 
+    _LANGUAGE_NOT_SET = 0,
+    LANGUAGE = 9,
+  }
+
+  export enum TaskCase { 
+    _TASK_NOT_SET = 0,
+    TASK = 10,
+  }
+
+  export enum S2tServiceConfigCase { 
+    _S2T_SERVICE_CONFIG_NOT_SET = 0,
+    S2T_SERVICE_CONFIG = 11,
+  }
+
+  export enum S2tCloudProviderConfigCase { 
+    _S2T_CLOUD_PROVIDER_CONFIG_NOT_SET = 0,
+    S2T_CLOUD_PROVIDER_CONFIG = 12,
+  }
+}
+
+export class S2tCloudProviderConfig extends jspb.Message {
+  getS2tCloudProviderConfigAmazon(): S2tCloudProviderConfigAmazon | undefined;
+  setS2tCloudProviderConfigAmazon(value?: S2tCloudProviderConfigAmazon): S2tCloudProviderConfig;
+  hasS2tCloudProviderConfigAmazon(): boolean;
+  clearS2tCloudProviderConfigAmazon(): S2tCloudProviderConfig;
+
+  getS2tCloudProviderConfigDeepgram(): S2tCloudProviderConfigDeepgram | undefined;
+  setS2tCloudProviderConfigDeepgram(value?: S2tCloudProviderConfigDeepgram): S2tCloudProviderConfig;
+  hasS2tCloudProviderConfigDeepgram(): boolean;
+  clearS2tCloudProviderConfigDeepgram(): S2tCloudProviderConfig;
+
+  getS2tCloudProviderConfigGoogle(): S2tCloudProviderConfigGoogle | undefined;
+  setS2tCloudProviderConfigGoogle(value?: S2tCloudProviderConfigGoogle): S2tCloudProviderConfig;
+  hasS2tCloudProviderConfigGoogle(): boolean;
+  clearS2tCloudProviderConfigGoogle(): S2tCloudProviderConfig;
+
+  getS2tCloudProviderConfigMicrosoft(): S2tCloudProviderConfigMicrosoft | undefined;
+  setS2tCloudProviderConfigMicrosoft(value?: S2tCloudProviderConfigMicrosoft): S2tCloudProviderConfig;
+  hasS2tCloudProviderConfigMicrosoft(): boolean;
+  clearS2tCloudProviderConfigMicrosoft(): S2tCloudProviderConfig;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tCloudProviderConfig.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tCloudProviderConfig): S2tCloudProviderConfig.AsObject;
+  static serializeBinaryToWriter(message: S2tCloudProviderConfig, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tCloudProviderConfig;
+  static deserializeBinaryFromReader(message: S2tCloudProviderConfig, reader: jspb.BinaryReader): S2tCloudProviderConfig;
+}
+
+export namespace S2tCloudProviderConfig {
+  export type AsObject = {
+    s2tCloudProviderConfigAmazon?: S2tCloudProviderConfigAmazon.AsObject,
+    s2tCloudProviderConfigDeepgram?: S2tCloudProviderConfigDeepgram.AsObject,
+    s2tCloudProviderConfigGoogle?: S2tCloudProviderConfigGoogle.AsObject,
+    s2tCloudProviderConfigMicrosoft?: S2tCloudProviderConfigMicrosoft.AsObject,
+  }
+
+  export enum S2tCloudProviderConfigAmazonCase { 
+    _S2T_CLOUD_PROVIDER_CONFIG_AMAZON_NOT_SET = 0,
+    S2T_CLOUD_PROVIDER_CONFIG_AMAZON = 1,
+  }
+
+  export enum S2tCloudProviderConfigDeepgramCase { 
+    _S2T_CLOUD_PROVIDER_CONFIG_DEEPGRAM_NOT_SET = 0,
+    S2T_CLOUD_PROVIDER_CONFIG_DEEPGRAM = 2,
+  }
+
+  export enum S2tCloudProviderConfigGoogleCase { 
+    _S2T_CLOUD_PROVIDER_CONFIG_GOOGLE_NOT_SET = 0,
+    S2T_CLOUD_PROVIDER_CONFIG_GOOGLE = 3,
+  }
+
+  export enum S2tCloudProviderConfigMicrosoftCase { 
+    _S2T_CLOUD_PROVIDER_CONFIG_MICROSOFT_NOT_SET = 0,
+    S2T_CLOUD_PROVIDER_CONFIG_MICROSOFT = 4,
+  }
+}
+
+export class S2tCloudProviderConfigAmazon extends jspb.Message {
+  getEnablePartialResultsStabilization(): boolean;
+  setEnablePartialResultsStabilization(value: boolean): S2tCloudProviderConfigAmazon;
+  hasEnablePartialResultsStabilization(): boolean;
+  clearEnablePartialResultsStabilization(): S2tCloudProviderConfigAmazon;
+
+  getPartialResultsStability(): string;
+  setPartialResultsStability(value: string): S2tCloudProviderConfigAmazon;
+  hasPartialResultsStability(): boolean;
+  clearPartialResultsStability(): S2tCloudProviderConfigAmazon;
+
+  getLanguageModelName(): string;
+  setLanguageModelName(value: string): S2tCloudProviderConfigAmazon;
+  hasLanguageModelName(): boolean;
+  clearLanguageModelName(): S2tCloudProviderConfigAmazon;
+
+  getVocabularyName(): string;
+  setVocabularyName(value: string): S2tCloudProviderConfigAmazon;
+  hasVocabularyName(): boolean;
+  clearVocabularyName(): S2tCloudProviderConfigAmazon;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tCloudProviderConfigAmazon.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tCloudProviderConfigAmazon): S2tCloudProviderConfigAmazon.AsObject;
+  static serializeBinaryToWriter(message: S2tCloudProviderConfigAmazon, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tCloudProviderConfigAmazon;
+  static deserializeBinaryFromReader(message: S2tCloudProviderConfigAmazon, reader: jspb.BinaryReader): S2tCloudProviderConfigAmazon;
+}
+
+export namespace S2tCloudProviderConfigAmazon {
+  export type AsObject = {
+    enablePartialResultsStabilization?: boolean,
+    partialResultsStability?: string,
+    languageModelName?: string,
+    vocabularyName?: string,
+  }
+
+  export enum EnablePartialResultsStabilizationCase { 
+    _ENABLE_PARTIAL_RESULTS_STABILIZATION_NOT_SET = 0,
+    ENABLE_PARTIAL_RESULTS_STABILIZATION = 1,
+  }
+
+  export enum PartialResultsStabilityCase { 
+    _PARTIAL_RESULTS_STABILITY_NOT_SET = 0,
+    PARTIAL_RESULTS_STABILITY = 2,
+  }
+
+  export enum LanguageModelNameCase { 
+    _LANGUAGE_MODEL_NAME_NOT_SET = 0,
+    LANGUAGE_MODEL_NAME = 3,
+  }
+
+  export enum VocabularyNameCase { 
+    _VOCABULARY_NAME_NOT_SET = 0,
+    VOCABULARY_NAME = 4,
+  }
+}
+
+export class S2tCloudProviderConfigDeepgram extends jspb.Message {
+  getPunctuate(): boolean;
+  setPunctuate(value: boolean): S2tCloudProviderConfigDeepgram;
+  hasPunctuate(): boolean;
+  clearPunctuate(): S2tCloudProviderConfigDeepgram;
+
+  getSmartFormat(): boolean;
+  setSmartFormat(value: boolean): S2tCloudProviderConfigDeepgram;
+  hasSmartFormat(): boolean;
+  clearSmartFormat(): S2tCloudProviderConfigDeepgram;
+
+  getNumerals(): boolean;
+  setNumerals(value: boolean): S2tCloudProviderConfigDeepgram;
+  hasNumerals(): boolean;
+  clearNumerals(): S2tCloudProviderConfigDeepgram;
+
+  getMeasurements(): boolean;
+  setMeasurements(value: boolean): S2tCloudProviderConfigDeepgram;
+  hasMeasurements(): boolean;
+  clearMeasurements(): S2tCloudProviderConfigDeepgram;
+
+  getDictation(): boolean;
+  setDictation(value: boolean): S2tCloudProviderConfigDeepgram;
+  hasDictation(): boolean;
+  clearDictation(): S2tCloudProviderConfigDeepgram;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tCloudProviderConfigDeepgram.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tCloudProviderConfigDeepgram): S2tCloudProviderConfigDeepgram.AsObject;
+  static serializeBinaryToWriter(message: S2tCloudProviderConfigDeepgram, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tCloudProviderConfigDeepgram;
+  static deserializeBinaryFromReader(message: S2tCloudProviderConfigDeepgram, reader: jspb.BinaryReader): S2tCloudProviderConfigDeepgram;
+}
+
+export namespace S2tCloudProviderConfigDeepgram {
+  export type AsObject = {
+    punctuate?: boolean,
+    smartFormat?: boolean,
+    numerals?: boolean,
+    measurements?: boolean,
+    dictation?: boolean,
+  }
+
+  export enum PunctuateCase { 
+    _PUNCTUATE_NOT_SET = 0,
+    PUNCTUATE = 1,
+  }
+
+  export enum SmartFormatCase { 
+    _SMART_FORMAT_NOT_SET = 0,
+    SMART_FORMAT = 2,
+  }
+
+  export enum NumeralsCase { 
+    _NUMERALS_NOT_SET = 0,
+    NUMERALS = 3,
+  }
+
+  export enum MeasurementsCase { 
+    _MEASUREMENTS_NOT_SET = 0,
+    MEASUREMENTS = 4,
+  }
+
+  export enum DictationCase { 
+    _DICTATION_NOT_SET = 0,
+    DICTATION = 5,
+  }
+}
+
+export class S2tCloudProviderConfigGoogle extends jspb.Message {
+  getEnableAutomaticPunctuation(): boolean;
+  setEnableAutomaticPunctuation(value: boolean): S2tCloudProviderConfigGoogle;
+  hasEnableAutomaticPunctuation(): boolean;
+  clearEnableAutomaticPunctuation(): S2tCloudProviderConfigGoogle;
+
+  getEnableWordTimeOffsets(): boolean;
+  setEnableWordTimeOffsets(value: boolean): S2tCloudProviderConfigGoogle;
+  hasEnableWordTimeOffsets(): boolean;
+  clearEnableWordTimeOffsets(): S2tCloudProviderConfigGoogle;
+
+  getEnableWordConfidence(): boolean;
+  setEnableWordConfidence(value: boolean): S2tCloudProviderConfigGoogle;
+  hasEnableWordConfidence(): boolean;
+  clearEnableWordConfidence(): S2tCloudProviderConfigGoogle;
+
+  getTranscriptNormalization(): boolean;
+  setTranscriptNormalization(value: boolean): S2tCloudProviderConfigGoogle;
+  hasTranscriptNormalization(): boolean;
+  clearTranscriptNormalization(): S2tCloudProviderConfigGoogle;
+
+  getMaxAlternatives(): number;
+  setMaxAlternatives(value: number): S2tCloudProviderConfigGoogle;
+  hasMaxAlternatives(): boolean;
+  clearMaxAlternatives(): S2tCloudProviderConfigGoogle;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tCloudProviderConfigGoogle.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tCloudProviderConfigGoogle): S2tCloudProviderConfigGoogle.AsObject;
+  static serializeBinaryToWriter(message: S2tCloudProviderConfigGoogle, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tCloudProviderConfigGoogle;
+  static deserializeBinaryFromReader(message: S2tCloudProviderConfigGoogle, reader: jspb.BinaryReader): S2tCloudProviderConfigGoogle;
+}
+
+export namespace S2tCloudProviderConfigGoogle {
+  export type AsObject = {
+    enableAutomaticPunctuation?: boolean,
+    enableWordTimeOffsets?: boolean,
+    enableWordConfidence?: boolean,
+    transcriptNormalization?: boolean,
+    maxAlternatives?: number,
+  }
+
+  export enum EnableAutomaticPunctuationCase { 
+    _ENABLE_AUTOMATIC_PUNCTUATION_NOT_SET = 0,
+    ENABLE_AUTOMATIC_PUNCTUATION = 1,
+  }
+
+  export enum EnableWordTimeOffsetsCase { 
+    _ENABLE_WORD_TIME_OFFSETS_NOT_SET = 0,
+    ENABLE_WORD_TIME_OFFSETS = 2,
+  }
+
+  export enum EnableWordConfidenceCase { 
+    _ENABLE_WORD_CONFIDENCE_NOT_SET = 0,
+    ENABLE_WORD_CONFIDENCE = 3,
+  }
+
+  export enum TranscriptNormalizationCase { 
+    _TRANSCRIPT_NORMALIZATION_NOT_SET = 0,
+    TRANSCRIPT_NORMALIZATION = 4,
+  }
+
+  export enum MaxAlternativesCase { 
+    _MAX_ALTERNATIVES_NOT_SET = 0,
+    MAX_ALTERNATIVES = 5,
+  }
+}
+
+export class S2tCloudProviderConfigMicrosoft extends jspb.Message {
+  getUseFastTranscriptionApi(): boolean;
+  setUseFastTranscriptionApi(value: boolean): S2tCloudProviderConfigMicrosoft;
+  hasUseFastTranscriptionApi(): boolean;
+  clearUseFastTranscriptionApi(): S2tCloudProviderConfigMicrosoft;
+
+  getUseDetailedOutputFormat(): boolean;
+  setUseDetailedOutputFormat(value: boolean): S2tCloudProviderConfigMicrosoft;
+  hasUseDetailedOutputFormat(): boolean;
+  clearUseDetailedOutputFormat(): S2tCloudProviderConfigMicrosoft;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tCloudProviderConfigMicrosoft.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tCloudProviderConfigMicrosoft): S2tCloudProviderConfigMicrosoft.AsObject;
+  static serializeBinaryToWriter(message: S2tCloudProviderConfigMicrosoft, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tCloudProviderConfigMicrosoft;
+  static deserializeBinaryFromReader(message: S2tCloudProviderConfigMicrosoft, reader: jspb.BinaryReader): S2tCloudProviderConfigMicrosoft;
+}
+
+export namespace S2tCloudProviderConfigMicrosoft {
+  export type AsObject = {
+    useFastTranscriptionApi?: boolean,
+    useDetailedOutputFormat?: boolean,
+  }
+
+  export enum UseFastTranscriptionApiCase { 
+    _USE_FAST_TRANSCRIPTION_API_NOT_SET = 0,
+    USE_FAST_TRANSCRIPTION_API = 1,
+  }
+
+  export enum UseDetailedOutputFormatCase { 
+    _USE_DETAILED_OUTPUT_FORMAT_NOT_SET = 0,
+    USE_DETAILED_OUTPUT_FORMAT = 2,
+  }
 }
 
 export class TranscriptionReturnOptions extends jspb.Message {
-	getReturnStartOfSpeech(): boolean;
-	setReturnStartOfSpeech(value: boolean): TranscriptionReturnOptions;
+  getReturnStartOfSpeech(): boolean;
+  setReturnStartOfSpeech(value: boolean): TranscriptionReturnOptions;
 
-	getReturnAudio(): boolean;
-	setReturnAudio(value: boolean): TranscriptionReturnOptions;
+  getReturnAudio(): boolean;
+  setReturnAudio(value: boolean): TranscriptionReturnOptions;
 
-	getReturnConfidenceScore(): boolean;
-	setReturnConfidenceScore(value: boolean): TranscriptionReturnOptions;
+  getReturnConfidenceScore(): boolean;
+  setReturnConfidenceScore(value: boolean): TranscriptionReturnOptions;
 
-	getReturnAlternativeTranscriptions(): boolean;
-	setReturnAlternativeTranscriptions(value: boolean): TranscriptionReturnOptions;
+  getReturnAlternativeTranscriptions(): boolean;
+  setReturnAlternativeTranscriptions(value: boolean): TranscriptionReturnOptions;
 
-	getReturnAlternativeTranscriptionsNr(): number;
-	setReturnAlternativeTranscriptionsNr(value: number): TranscriptionReturnOptions;
+  getReturnAlternativeTranscriptionsNr(): number;
+  setReturnAlternativeTranscriptionsNr(value: number): TranscriptionReturnOptions;
 
-	getReturnAlternativeWords(): boolean;
-	setReturnAlternativeWords(value: boolean): TranscriptionReturnOptions;
+  getReturnAlternativeWords(): boolean;
+  setReturnAlternativeWords(value: boolean): TranscriptionReturnOptions;
 
-	getReturnAlternativeWordsNr(): number;
-	setReturnAlternativeWordsNr(value: number): TranscriptionReturnOptions;
+  getReturnAlternativeWordsNr(): number;
+  setReturnAlternativeWordsNr(value: number): TranscriptionReturnOptions;
 
-	getReturnWordTiming(): boolean;
-	setReturnWordTiming(value: boolean): TranscriptionReturnOptions;
+  getReturnWordTiming(): boolean;
+  setReturnWordTiming(value: boolean): TranscriptionReturnOptions;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): TranscriptionReturnOptions.AsObject;
-	static toObject(includeInstance: boolean, msg: TranscriptionReturnOptions): TranscriptionReturnOptions.AsObject;
-	static serializeBinaryToWriter(message: TranscriptionReturnOptions, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): TranscriptionReturnOptions;
-	static deserializeBinaryFromReader(
-		message: TranscriptionReturnOptions,
-		reader: jspb.BinaryReader
-	): TranscriptionReturnOptions;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TranscriptionReturnOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: TranscriptionReturnOptions): TranscriptionReturnOptions.AsObject;
+  static serializeBinaryToWriter(message: TranscriptionReturnOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TranscriptionReturnOptions;
+  static deserializeBinaryFromReader(message: TranscriptionReturnOptions, reader: jspb.BinaryReader): TranscriptionReturnOptions;
 }
 
 export namespace TranscriptionReturnOptions {
-	export type AsObject = {
-		returnStartOfSpeech: boolean;
-		returnAudio: boolean;
-		returnConfidenceScore: boolean;
-		returnAlternativeTranscriptions: boolean;
-		returnAlternativeTranscriptionsNr: number;
-		returnAlternativeWords: boolean;
-		returnAlternativeWordsNr: number;
-		returnWordTiming: boolean;
-	};
+  export type AsObject = {
+    returnStartOfSpeech: boolean,
+    returnAudio: boolean,
+    returnConfidenceScore: boolean,
+    returnAlternativeTranscriptions: boolean,
+    returnAlternativeTranscriptionsNr: number,
+    returnAlternativeWords: boolean,
+    returnAlternativeWordsNr: number,
+    returnWordTiming: boolean,
+  }
 }
 
 export class UtteranceDetectionOptions extends jspb.Message {
-	getTranscribeNotFinal(): boolean;
-	setTranscribeNotFinal(value: boolean): UtteranceDetectionOptions;
+  getTranscribeNotFinal(): boolean;
+  setTranscribeNotFinal(value: boolean): UtteranceDetectionOptions;
+
+  getNextChunkTimeout(): number;
+  setNextChunkTimeout(value: number): UtteranceDetectionOptions;
 
-	getNextChunkTimeout(): number;
-	setNextChunkTimeout(value: number): UtteranceDetectionOptions;
+  getTurnDetection(): TurnDetectionOptions | undefined;
+  setTurnDetection(value?: TurnDetectionOptions): UtteranceDetectionOptions;
+  hasTurnDetection(): boolean;
+  clearTurnDetection(): UtteranceDetectionOptions;
 
-	getOneofTranscribeNotFinalCase(): UtteranceDetectionOptions.OneofTranscribeNotFinalCase;
+  getOneofTranscribeNotFinalCase(): UtteranceDetectionOptions.OneofTranscribeNotFinalCase;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): UtteranceDetectionOptions.AsObject;
-	static toObject(includeInstance: boolean, msg: UtteranceDetectionOptions): UtteranceDetectionOptions.AsObject;
-	static serializeBinaryToWriter(message: UtteranceDetectionOptions, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): UtteranceDetectionOptions;
-	static deserializeBinaryFromReader(
-		message: UtteranceDetectionOptions,
-		reader: jspb.BinaryReader
-	): UtteranceDetectionOptions;
+  getOneofTurnDetectionCase(): UtteranceDetectionOptions.OneofTurnDetectionCase;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): UtteranceDetectionOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: UtteranceDetectionOptions): UtteranceDetectionOptions.AsObject;
+  static serializeBinaryToWriter(message: UtteranceDetectionOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): UtteranceDetectionOptions;
+  static deserializeBinaryFromReader(message: UtteranceDetectionOptions, reader: jspb.BinaryReader): UtteranceDetectionOptions;
 }
 
 export namespace UtteranceDetectionOptions {
-	export type AsObject = {
-		transcribeNotFinal: boolean;
-		nextChunkTimeout: number;
-	};
+  export type AsObject = {
+    transcribeNotFinal: boolean,
+    nextChunkTimeout: number,
+    turnDetection?: TurnDetectionOptions.AsObject,
+  }
+
+  export enum OneofTranscribeNotFinalCase { 
+    ONEOF_TRANSCRIBE_NOT_FINAL_NOT_SET = 0,
+    TRANSCRIBE_NOT_FINAL = 1,
+  }
 
-	export enum OneofTranscribeNotFinalCase {
-		ONEOF_TRANSCRIBE_NOT_FINAL_NOT_SET = 0,
-		TRANSCRIBE_NOT_FINAL = 1
-	}
+  export enum OneofTurnDetectionCase { 
+    ONEOF_TURN_DETECTION_NOT_SET = 0,
+    TURN_DETECTION = 3,
+  }
 }
 
 export class PostProcessingOptions extends jspb.Message {
-	getSpellingCorrection(): boolean;
-	setSpellingCorrection(value: boolean): PostProcessingOptions;
+  getSpellingCorrection(): boolean;
+  setSpellingCorrection(value: boolean): PostProcessingOptions;
 
-	getNormalize(): boolean;
-	setNormalize(value: boolean): PostProcessingOptions;
+  getNormalize(): boolean;
+  setNormalize(value: boolean): PostProcessingOptions;
 
-	getConfig(): PostProcessing | undefined;
-	setConfig(value?: PostProcessing): PostProcessingOptions;
-	hasConfig(): boolean;
-	clearConfig(): PostProcessingOptions;
+  getConfig(): PostProcessing | undefined;
+  setConfig(value?: PostProcessing): PostProcessingOptions;
+  hasConfig(): boolean;
+  clearConfig(): PostProcessingOptions;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): PostProcessingOptions.AsObject;
-	static toObject(includeInstance: boolean, msg: PostProcessingOptions): PostProcessingOptions.AsObject;
-	static serializeBinaryToWriter(message: PostProcessingOptions, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): PostProcessingOptions;
-	static deserializeBinaryFromReader(message: PostProcessingOptions, reader: jspb.BinaryReader): PostProcessingOptions;
+  getLlmPostProcessing(): boolean;
+  setLlmPostProcessing(value: boolean): PostProcessingOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PostProcessingOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: PostProcessingOptions): PostProcessingOptions.AsObject;
+  static serializeBinaryToWriter(message: PostProcessingOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PostProcessingOptions;
+  static deserializeBinaryFromReader(message: PostProcessingOptions, reader: jspb.BinaryReader): PostProcessingOptions;
 }
 
 export namespace PostProcessingOptions {
-	export type AsObject = {
-		spellingCorrection: boolean;
-		normalize: boolean;
-		config?: PostProcessing.AsObject;
-	};
+  export type AsObject = {
+    spellingCorrection: boolean,
+    normalize: boolean,
+    config?: PostProcessing.AsObject,
+    llmPostProcessing: boolean,
+  }
 }
 
 export class Transcription extends jspb.Message {
-	getTranscription(): string;
-	setTranscription(value: string): Transcription;
+  getTranscription(): string;
+  setTranscription(value: string): Transcription;
 
-	getConfidenceScore(): number;
-	setConfidenceScore(value: number): Transcription;
+  getConfidenceScore(): number;
+  setConfidenceScore(value: number): Transcription;
 
-	getWordsList(): Array<WordDetail>;
-	setWordsList(value: Array<WordDetail>): Transcription;
-	clearWordsList(): Transcription;
-	addWords(value?: WordDetail, index?: number): WordDetail;
+  getWordsList(): Array<WordDetail>;
+  setWordsList(value: Array<WordDetail>): Transcription;
+  clearWordsList(): Transcription;
+  addWords(value?: WordDetail, index?: number): WordDetail;
 
-	getAlternativesList(): Array<TranscriptionAlternative>;
-	setAlternativesList(value: Array<TranscriptionAlternative>): Transcription;
-	clearAlternativesList(): Transcription;
-	addAlternatives(value?: TranscriptionAlternative, index?: number): TranscriptionAlternative;
+  getAlternativesList(): Array<TranscriptionAlternative>;
+  setAlternativesList(value: Array<TranscriptionAlternative>): Transcription;
+  clearAlternativesList(): Transcription;
+  addAlternatives(value?: TranscriptionAlternative, index?: number): TranscriptionAlternative;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): Transcription.AsObject;
-	static toObject(includeInstance: boolean, msg: Transcription): Transcription.AsObject;
-	static serializeBinaryToWriter(message: Transcription, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): Transcription;
-	static deserializeBinaryFromReader(message: Transcription, reader: jspb.BinaryReader): Transcription;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Transcription.AsObject;
+  static toObject(includeInstance: boolean, msg: Transcription): Transcription.AsObject;
+  static serializeBinaryToWriter(message: Transcription, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Transcription;
+  static deserializeBinaryFromReader(message: Transcription, reader: jspb.BinaryReader): Transcription;
 }
 
 export namespace Transcription {
-	export type AsObject = {
-		transcription: string;
-		confidenceScore: number;
-		wordsList: Array<WordDetail.AsObject>;
-		alternativesList: Array<TranscriptionAlternative.AsObject>;
-	};
+  export type AsObject = {
+    transcription: string,
+    confidenceScore: number,
+    wordsList: Array<WordDetail.AsObject>,
+    alternativesList: Array<TranscriptionAlternative.AsObject>,
+  }
 }
 
 export class TranscriptionAlternative extends jspb.Message {
-	getTranscript(): string;
-	setTranscript(value: string): TranscriptionAlternative;
+  getTranscript(): string;
+  setTranscript(value: string): TranscriptionAlternative;
 
-	getConfidence(): number;
-	setConfidence(value: number): TranscriptionAlternative;
+  getConfidence(): number;
+  setConfidence(value: number): TranscriptionAlternative;
 
-	getWordsList(): Array<WordDetail>;
-	setWordsList(value: Array<WordDetail>): TranscriptionAlternative;
-	clearWordsList(): TranscriptionAlternative;
-	addWords(value?: WordDetail, index?: number): WordDetail;
+  getWordsList(): Array<WordDetail>;
+  setWordsList(value: Array<WordDetail>): TranscriptionAlternative;
+  clearWordsList(): TranscriptionAlternative;
+  addWords(value?: WordDetail, index?: number): WordDetail;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): TranscriptionAlternative.AsObject;
-	static toObject(includeInstance: boolean, msg: TranscriptionAlternative): TranscriptionAlternative.AsObject;
-	static serializeBinaryToWriter(message: TranscriptionAlternative, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): TranscriptionAlternative;
-	static deserializeBinaryFromReader(
-		message: TranscriptionAlternative,
-		reader: jspb.BinaryReader
-	): TranscriptionAlternative;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TranscriptionAlternative.AsObject;
+  static toObject(includeInstance: boolean, msg: TranscriptionAlternative): TranscriptionAlternative.AsObject;
+  static serializeBinaryToWriter(message: TranscriptionAlternative, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TranscriptionAlternative;
+  static deserializeBinaryFromReader(message: TranscriptionAlternative, reader: jspb.BinaryReader): TranscriptionAlternative;
 }
 
 export namespace TranscriptionAlternative {
-	export type AsObject = {
-		transcript: string;
-		confidence: number;
-		wordsList: Array<WordDetail.AsObject>;
-	};
+  export type AsObject = {
+    transcript: string,
+    confidence: number,
+    wordsList: Array<WordDetail.AsObject>,
+  }
 }
 
 export class WordDetail extends jspb.Message {
-	getStartTime(): number;
-	setStartTime(value: number): WordDetail;
+  getStartTime(): number;
+  setStartTime(value: number): WordDetail;
 
-	getEndTime(): number;
-	setEndTime(value: number): WordDetail;
+  getEndTime(): number;
+  setEndTime(value: number): WordDetail;
 
-	getWord(): string;
-	setWord(value: string): WordDetail;
+  getWord(): string;
+  setWord(value: string): WordDetail;
 
-	getConfidence(): number;
-	setConfidence(value: number): WordDetail;
+  getConfidence(): number;
+  setConfidence(value: number): WordDetail;
 
-	getWordAlternativesList(): Array<WordAlternative>;
-	setWordAlternativesList(value: Array<WordAlternative>): WordDetail;
-	clearWordAlternativesList(): WordDetail;
-	addWordAlternatives(value?: WordAlternative, index?: number): WordAlternative;
+  getWordAlternativesList(): Array<WordAlternative>;
+  setWordAlternativesList(value: Array<WordAlternative>): WordDetail;
+  clearWordAlternativesList(): WordDetail;
+  addWordAlternatives(value?: WordAlternative, index?: number): WordAlternative;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): WordDetail.AsObject;
-	static toObject(includeInstance: boolean, msg: WordDetail): WordDetail.AsObject;
-	static serializeBinaryToWriter(message: WordDetail, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): WordDetail;
-	static deserializeBinaryFromReader(message: WordDetail, reader: jspb.BinaryReader): WordDetail;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): WordDetail.AsObject;
+  static toObject(includeInstance: boolean, msg: WordDetail): WordDetail.AsObject;
+  static serializeBinaryToWriter(message: WordDetail, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): WordDetail;
+  static deserializeBinaryFromReader(message: WordDetail, reader: jspb.BinaryReader): WordDetail;
 }
 
 export namespace WordDetail {
-	export type AsObject = {
-		startTime: number;
-		endTime: number;
-		word: string;
-		confidence: number;
-		wordAlternativesList: Array<WordAlternative.AsObject>;
-	};
+  export type AsObject = {
+    startTime: number,
+    endTime: number,
+    word: string,
+    confidence: number,
+    wordAlternativesList: Array<WordAlternative.AsObject>,
+  }
 }
 
 export class WordAlternative extends jspb.Message {
-	getWord(): string;
-	setWord(value: string): WordAlternative;
+  getWord(): string;
+  setWord(value: string): WordAlternative;
 
-	getConfidence(): number;
-	setConfidence(value: number): WordAlternative;
+  getConfidence(): number;
+  setConfidence(value: number): WordAlternative;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): WordAlternative.AsObject;
-	static toObject(includeInstance: boolean, msg: WordAlternative): WordAlternative.AsObject;
-	static serializeBinaryToWriter(message: WordAlternative, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): WordAlternative;
-	static deserializeBinaryFromReader(message: WordAlternative, reader: jspb.BinaryReader): WordAlternative;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): WordAlternative.AsObject;
+  static toObject(includeInstance: boolean, msg: WordAlternative): WordAlternative.AsObject;
+  static serializeBinaryToWriter(message: WordAlternative, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): WordAlternative;
+  static deserializeBinaryFromReader(message: WordAlternative, reader: jspb.BinaryReader): WordAlternative;
 }
 
 export namespace WordAlternative {
-	export type AsObject = {
-		word: string;
-		confidence: number;
-	};
+  export type AsObject = {
+    word: string,
+    confidence: number,
+  }
 }
 
 export class TranscribeStreamRequest extends jspb.Message {
-	getAudioChunk(): Uint8Array | string;
-	getAudioChunk_asU8(): Uint8Array;
-	getAudioChunk_asB64(): string;
-	setAudioChunk(value: Uint8Array | string): TranscribeStreamRequest;
+  getAudioChunk(): Uint8Array | string;
+  getAudioChunk_asU8(): Uint8Array;
+  getAudioChunk_asB64(): string;
+  setAudioChunk(value: Uint8Array | string): TranscribeStreamRequest;
 
-	getEndOfStream(): boolean;
-	setEndOfStream(value: boolean): TranscribeStreamRequest;
+  getEndOfStream(): boolean;
+  setEndOfStream(value: boolean): TranscribeStreamRequest;
 
-	getConfig(): TranscribeRequestConfig | undefined;
-	setConfig(value?: TranscribeRequestConfig): TranscribeStreamRequest;
-	hasConfig(): boolean;
-	clearConfig(): TranscribeStreamRequest;
+  getConfig(): TranscribeRequestConfig | undefined;
+  setConfig(value?: TranscribeRequestConfig): TranscribeStreamRequest;
+  hasConfig(): boolean;
+  clearConfig(): TranscribeStreamRequest;
 
-	getMuteAudio(): boolean;
-	setMuteAudio(value: boolean): TranscribeStreamRequest;
+  getMuteAudio(): boolean;
+  setMuteAudio(value: boolean): TranscribeStreamRequest;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): TranscribeStreamRequest.AsObject;
-	static toObject(includeInstance: boolean, msg: TranscribeStreamRequest): TranscribeStreamRequest.AsObject;
-	static serializeBinaryToWriter(message: TranscribeStreamRequest, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): TranscribeStreamRequest;
-	static deserializeBinaryFromReader(
-		message: TranscribeStreamRequest,
-		reader: jspb.BinaryReader
-	): TranscribeStreamRequest;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TranscribeStreamRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: TranscribeStreamRequest): TranscribeStreamRequest.AsObject;
+  static serializeBinaryToWriter(message: TranscribeStreamRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TranscribeStreamRequest;
+  static deserializeBinaryFromReader(message: TranscribeStreamRequest, reader: jspb.BinaryReader): TranscribeStreamRequest;
 }
 
 export namespace TranscribeStreamRequest {
-	export type AsObject = {
-		audioChunk: Uint8Array | string;
-		endOfStream: boolean;
-		config?: TranscribeRequestConfig.AsObject;
-		muteAudio: boolean;
-	};
+  export type AsObject = {
+    audioChunk: Uint8Array | string,
+    endOfStream: boolean,
+    config?: TranscribeRequestConfig.AsObject,
+    muteAudio: boolean,
+  }
 }
 
 export class TranscribeStreamResponse extends jspb.Message {
-	getTranscriptionsList(): Array<Transcription>;
-	setTranscriptionsList(value: Array<Transcription>): TranscribeStreamResponse;
-	clearTranscriptionsList(): TranscribeStreamResponse;
-	addTranscriptions(value?: Transcription, index?: number): Transcription;
+  getTranscriptionsList(): Array<Transcription>;
+  setTranscriptionsList(value: Array<Transcription>): TranscribeStreamResponse;
+  clearTranscriptionsList(): TranscribeStreamResponse;
+  addTranscriptions(value?: Transcription, index?: number): Transcription;
 
-	getTime(): number;
-	setTime(value: number): TranscribeStreamResponse;
+  getTime(): number;
+  setTime(value: number): TranscribeStreamResponse;
 
-	getFinal(): boolean;
-	setFinal(value: boolean): TranscribeStreamResponse;
+  getFinal(): boolean;
+  setFinal(value: boolean): TranscribeStreamResponse;
 
-	getReturnAudio(): boolean;
-	setReturnAudio(value: boolean): TranscribeStreamResponse;
+  getReturnAudio(): boolean;
+  setReturnAudio(value: boolean): TranscribeStreamResponse;
 
-	getAudio(): Uint8Array | string;
-	getAudio_asU8(): Uint8Array;
-	getAudio_asB64(): string;
-	setAudio(value: Uint8Array | string): TranscribeStreamResponse;
+  getAudio(): Uint8Array | string;
+  getAudio_asU8(): Uint8Array;
+  getAudio_asB64(): string;
+  setAudio(value: Uint8Array | string): TranscribeStreamResponse;
 
-	getUtteranceStart(): boolean;
-	setUtteranceStart(value: boolean): TranscribeStreamResponse;
+  getUtteranceStart(): boolean;
+  setUtteranceStart(value: boolean): TranscribeStreamResponse;
 
-	getAudioUuid(): string;
-	setAudioUuid(value: string): TranscribeStreamResponse;
+  getAudioUuid(): string;
+  setAudioUuid(value: string): TranscribeStreamResponse;
 
-	getConfig(): TranscribeRequestConfig | undefined;
-	setConfig(value?: TranscribeRequestConfig): TranscribeStreamResponse;
-	hasConfig(): boolean;
-	clearConfig(): TranscribeStreamResponse;
+  getConfig(): TranscribeRequestConfig | undefined;
+  setConfig(value?: TranscribeRequestConfig): TranscribeStreamResponse;
+  hasConfig(): boolean;
+  clearConfig(): TranscribeStreamResponse;
 
-	getOneofConfigCase(): TranscribeStreamResponse.OneofConfigCase;
+  getOneofConfigCase(): TranscribeStreamResponse.OneofConfigCase;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): TranscribeStreamResponse.AsObject;
-	static toObject(includeInstance: boolean, msg: TranscribeStreamResponse): TranscribeStreamResponse.AsObject;
-	static serializeBinaryToWriter(message: TranscribeStreamResponse, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): TranscribeStreamResponse;
-	static deserializeBinaryFromReader(
-		message: TranscribeStreamResponse,
-		reader: jspb.BinaryReader
-	): TranscribeStreamResponse;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TranscribeStreamResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: TranscribeStreamResponse): TranscribeStreamResponse.AsObject;
+  static serializeBinaryToWriter(message: TranscribeStreamResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TranscribeStreamResponse;
+  static deserializeBinaryFromReader(message: TranscribeStreamResponse, reader: jspb.BinaryReader): TranscribeStreamResponse;
 }
 
 export namespace TranscribeStreamResponse {
-	export type AsObject = {
-		transcriptionsList: Array<Transcription.AsObject>;
-		time: number;
-		pb_final: boolean;
-		returnAudio: boolean;
-		audio: Uint8Array | string;
-		utteranceStart: boolean;
-		audioUuid: string;
-		config?: TranscribeRequestConfig.AsObject;
-	};
-
-	export enum OneofConfigCase {
-		ONEOF_CONFIG_NOT_SET = 0,
-		CONFIG = 8
-	}
+  export type AsObject = {
+    transcriptionsList: Array<Transcription.AsObject>,
+    time: number,
+    pb_final: boolean,
+    returnAudio: boolean,
+    audio: Uint8Array | string,
+    utteranceStart: boolean,
+    audioUuid: string,
+    config?: TranscribeRequestConfig.AsObject,
+  }
+
+  export enum OneofConfigCase { 
+    ONEOF_CONFIG_NOT_SET = 0,
+    CONFIG = 8,
+  }
 }
 
 export class TranscribeFileRequest extends jspb.Message {
-	getAudioFile(): Uint8Array | string;
-	getAudioFile_asU8(): Uint8Array;
-	getAudioFile_asB64(): string;
-	setAudioFile(value: Uint8Array | string): TranscribeFileRequest;
+  getAudioFile(): Uint8Array | string;
+  getAudioFile_asU8(): Uint8Array;
+  getAudioFile_asB64(): string;
+  setAudioFile(value: Uint8Array | string): TranscribeFileRequest;
 
-	getConfig(): TranscribeRequestConfig | undefined;
-	setConfig(value?: TranscribeRequestConfig): TranscribeFileRequest;
-	hasConfig(): boolean;
-	clearConfig(): TranscribeFileRequest;
+  getConfig(): TranscribeRequestConfig | undefined;
+  setConfig(value?: TranscribeRequestConfig): TranscribeFileRequest;
+  hasConfig(): boolean;
+  clearConfig(): TranscribeFileRequest;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): TranscribeFileRequest.AsObject;
-	static toObject(includeInstance: boolean, msg: TranscribeFileRequest): TranscribeFileRequest.AsObject;
-	static serializeBinaryToWriter(message: TranscribeFileRequest, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): TranscribeFileRequest;
-	static deserializeBinaryFromReader(message: TranscribeFileRequest, reader: jspb.BinaryReader): TranscribeFileRequest;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TranscribeFileRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: TranscribeFileRequest): TranscribeFileRequest.AsObject;
+  static serializeBinaryToWriter(message: TranscribeFileRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TranscribeFileRequest;
+  static deserializeBinaryFromReader(message: TranscribeFileRequest, reader: jspb.BinaryReader): TranscribeFileRequest;
 }
 
 export namespace TranscribeFileRequest {
-	export type AsObject = {
-		audioFile: Uint8Array | string;
-		config?: TranscribeRequestConfig.AsObject;
-	};
+  export type AsObject = {
+    audioFile: Uint8Array | string,
+    config?: TranscribeRequestConfig.AsObject,
+  }
 }
 
 export class TranscribeFileResponse extends jspb.Message {
-	getTranscriptionsList(): Array<Transcription>;
-	setTranscriptionsList(value: Array<Transcription>): TranscribeFileResponse;
-	clearTranscriptionsList(): TranscribeFileResponse;
-	addTranscriptions(value?: Transcription, index?: number): Transcription;
+  getTranscriptionsList(): Array<Transcription>;
+  setTranscriptionsList(value: Array<Transcription>): TranscribeFileResponse;
+  clearTranscriptionsList(): TranscribeFileResponse;
+  addTranscriptions(value?: Transcription, index?: number): Transcription;
 
-	getTime(): number;
-	setTime(value: number): TranscribeFileResponse;
+  getTime(): number;
+  setTime(value: number): TranscribeFileResponse;
 
-	getAudioUuid(): string;
-	setAudioUuid(value: string): TranscribeFileResponse;
+  getAudioUuid(): string;
+  setAudioUuid(value: string): TranscribeFileResponse;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): TranscribeFileResponse.AsObject;
-	static toObject(includeInstance: boolean, msg: TranscribeFileResponse): TranscribeFileResponse.AsObject;
-	static serializeBinaryToWriter(message: TranscribeFileResponse, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): TranscribeFileResponse;
-	static deserializeBinaryFromReader(
-		message: TranscribeFileResponse,
-		reader: jspb.BinaryReader
-	): TranscribeFileResponse;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TranscribeFileResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: TranscribeFileResponse): TranscribeFileResponse.AsObject;
+  static serializeBinaryToWriter(message: TranscribeFileResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TranscribeFileResponse;
+  static deserializeBinaryFromReader(message: TranscribeFileResponse, reader: jspb.BinaryReader): TranscribeFileResponse;
 }
 
 export namespace TranscribeFileResponse {
-	export type AsObject = {
-		transcriptionsList: Array<Transcription.AsObject>;
-		time: number;
-		audioUuid: string;
-	};
+  export type AsObject = {
+    transcriptionsList: Array<Transcription.AsObject>,
+    time: number,
+    audioUuid: string,
+  }
 }
 
 export class S2tPipelineId extends jspb.Message {
-	getId(): string;
-	setId(value: string): S2tPipelineId;
+  getId(): string;
+  setId(value: string): S2tPipelineId;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): S2tPipelineId.AsObject;
-	static toObject(includeInstance: boolean, msg: S2tPipelineId): S2tPipelineId.AsObject;
-	static serializeBinaryToWriter(message: S2tPipelineId, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): S2tPipelineId;
-	static deserializeBinaryFromReader(message: S2tPipelineId, reader: jspb.BinaryReader): S2tPipelineId;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tPipelineId.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tPipelineId): S2tPipelineId.AsObject;
+  static serializeBinaryToWriter(message: S2tPipelineId, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tPipelineId;
+  static deserializeBinaryFromReader(message: S2tPipelineId, reader: jspb.BinaryReader): S2tPipelineId;
 }
 
 export namespace S2tPipelineId {
-	export type AsObject = {
-		id: string;
-	};
+  export type AsObject = {
+    id: string,
+  }
 }
 
 export class ListS2tPipelinesRequest extends jspb.Message {
-	getLanguagesList(): Array<string>;
-	setLanguagesList(value: Array<string>): ListS2tPipelinesRequest;
-	clearLanguagesList(): ListS2tPipelinesRequest;
-	addLanguages(value: string, index?: number): ListS2tPipelinesRequest;
-
-	getPipelineOwnersList(): Array<string>;
-	setPipelineOwnersList(value: Array<string>): ListS2tPipelinesRequest;
-	clearPipelineOwnersList(): ListS2tPipelinesRequest;
-	addPipelineOwners(value: string, index?: number): ListS2tPipelinesRequest;
-
-	getDomainsList(): Array<string>;
-	setDomainsList(value: Array<string>): ListS2tPipelinesRequest;
-	clearDomainsList(): ListS2tPipelinesRequest;
-	addDomains(value: string, index?: number): ListS2tPipelinesRequest;
-
-	getRegisteredOnly(): boolean;
-	setRegisteredOnly(value: boolean): ListS2tPipelinesRequest;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): ListS2tPipelinesRequest.AsObject;
-	static toObject(includeInstance: boolean, msg: ListS2tPipelinesRequest): ListS2tPipelinesRequest.AsObject;
-	static serializeBinaryToWriter(message: ListS2tPipelinesRequest, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): ListS2tPipelinesRequest;
-	static deserializeBinaryFromReader(
-		message: ListS2tPipelinesRequest,
-		reader: jspb.BinaryReader
-	): ListS2tPipelinesRequest;
+  getLanguagesList(): Array<string>;
+  setLanguagesList(value: Array<string>): ListS2tPipelinesRequest;
+  clearLanguagesList(): ListS2tPipelinesRequest;
+  addLanguages(value: string, index?: number): ListS2tPipelinesRequest;
+
+  getPipelineOwnersList(): Array<string>;
+  setPipelineOwnersList(value: Array<string>): ListS2tPipelinesRequest;
+  clearPipelineOwnersList(): ListS2tPipelinesRequest;
+  addPipelineOwners(value: string, index?: number): ListS2tPipelinesRequest;
+
+  getDomainsList(): Array<string>;
+  setDomainsList(value: Array<string>): ListS2tPipelinesRequest;
+  clearDomainsList(): ListS2tPipelinesRequest;
+  addDomains(value: string, index?: number): ListS2tPipelinesRequest;
+
+  getRegisteredOnly(): boolean;
+  setRegisteredOnly(value: boolean): ListS2tPipelinesRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListS2tPipelinesRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ListS2tPipelinesRequest): ListS2tPipelinesRequest.AsObject;
+  static serializeBinaryToWriter(message: ListS2tPipelinesRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListS2tPipelinesRequest;
+  static deserializeBinaryFromReader(message: ListS2tPipelinesRequest, reader: jspb.BinaryReader): ListS2tPipelinesRequest;
 }
 
 export namespace ListS2tPipelinesRequest {
-	export type AsObject = {
-		languagesList: Array<string>;
-		pipelineOwnersList: Array<string>;
-		domainsList: Array<string>;
-		registeredOnly: boolean;
-	};
+  export type AsObject = {
+    languagesList: Array<string>,
+    pipelineOwnersList: Array<string>,
+    domainsList: Array<string>,
+    registeredOnly: boolean,
+  }
 }
 
 export class ListS2tPipelinesResponse extends jspb.Message {
-	getPipelineConfigsList(): Array<Speech2TextConfig>;
-	setPipelineConfigsList(value: Array<Speech2TextConfig>): ListS2tPipelinesResponse;
-	clearPipelineConfigsList(): ListS2tPipelinesResponse;
-	addPipelineConfigs(value?: Speech2TextConfig, index?: number): Speech2TextConfig;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): ListS2tPipelinesResponse.AsObject;
-	static toObject(includeInstance: boolean, msg: ListS2tPipelinesResponse): ListS2tPipelinesResponse.AsObject;
-	static serializeBinaryToWriter(message: ListS2tPipelinesResponse, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): ListS2tPipelinesResponse;
-	static deserializeBinaryFromReader(
-		message: ListS2tPipelinesResponse,
-		reader: jspb.BinaryReader
-	): ListS2tPipelinesResponse;
+  getPipelineConfigsList(): Array<Speech2TextConfig>;
+  setPipelineConfigsList(value: Array<Speech2TextConfig>): ListS2tPipelinesResponse;
+  clearPipelineConfigsList(): ListS2tPipelinesResponse;
+  addPipelineConfigs(value?: Speech2TextConfig, index?: number): Speech2TextConfig;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListS2tPipelinesResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ListS2tPipelinesResponse): ListS2tPipelinesResponse.AsObject;
+  static serializeBinaryToWriter(message: ListS2tPipelinesResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListS2tPipelinesResponse;
+  static deserializeBinaryFromReader(message: ListS2tPipelinesResponse, reader: jspb.BinaryReader): ListS2tPipelinesResponse;
 }
 
 export namespace ListS2tPipelinesResponse {
-	export type AsObject = {
-		pipelineConfigsList: Array<Speech2TextConfig.AsObject>;
-	};
+  export type AsObject = {
+    pipelineConfigsList: Array<Speech2TextConfig.AsObject>,
+  }
 }
 
 export class ListS2tLanguagesRequest extends jspb.Message {
-	getDomainsList(): Array<string>;
-	setDomainsList(value: Array<string>): ListS2tLanguagesRequest;
-	clearDomainsList(): ListS2tLanguagesRequest;
-	addDomains(value: string, index?: number): ListS2tLanguagesRequest;
-
-	getPipelineOwnersList(): Array<string>;
-	setPipelineOwnersList(value: Array<string>): ListS2tLanguagesRequest;
-	clearPipelineOwnersList(): ListS2tLanguagesRequest;
-	addPipelineOwners(value: string, index?: number): ListS2tLanguagesRequest;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): ListS2tLanguagesRequest.AsObject;
-	static toObject(includeInstance: boolean, msg: ListS2tLanguagesRequest): ListS2tLanguagesRequest.AsObject;
-	static serializeBinaryToWriter(message: ListS2tLanguagesRequest, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): ListS2tLanguagesRequest;
-	static deserializeBinaryFromReader(
-		message: ListS2tLanguagesRequest,
-		reader: jspb.BinaryReader
-	): ListS2tLanguagesRequest;
+  getDomainsList(): Array<string>;
+  setDomainsList(value: Array<string>): ListS2tLanguagesRequest;
+  clearDomainsList(): ListS2tLanguagesRequest;
+  addDomains(value: string, index?: number): ListS2tLanguagesRequest;
+
+  getPipelineOwnersList(): Array<string>;
+  setPipelineOwnersList(value: Array<string>): ListS2tLanguagesRequest;
+  clearPipelineOwnersList(): ListS2tLanguagesRequest;
+  addPipelineOwners(value: string, index?: number): ListS2tLanguagesRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListS2tLanguagesRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ListS2tLanguagesRequest): ListS2tLanguagesRequest.AsObject;
+  static serializeBinaryToWriter(message: ListS2tLanguagesRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListS2tLanguagesRequest;
+  static deserializeBinaryFromReader(message: ListS2tLanguagesRequest, reader: jspb.BinaryReader): ListS2tLanguagesRequest;
 }
 
 export namespace ListS2tLanguagesRequest {
-	export type AsObject = {
-		domainsList: Array<string>;
-		pipelineOwnersList: Array<string>;
-	};
+  export type AsObject = {
+    domainsList: Array<string>,
+    pipelineOwnersList: Array<string>,
+  }
 }
 
 export class ListS2tLanguagesResponse extends jspb.Message {
-	getLanguagesList(): Array<string>;
-	setLanguagesList(value: Array<string>): ListS2tLanguagesResponse;
-	clearLanguagesList(): ListS2tLanguagesResponse;
-	addLanguages(value: string, index?: number): ListS2tLanguagesResponse;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): ListS2tLanguagesResponse.AsObject;
-	static toObject(includeInstance: boolean, msg: ListS2tLanguagesResponse): ListS2tLanguagesResponse.AsObject;
-	static serializeBinaryToWriter(message: ListS2tLanguagesResponse, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): ListS2tLanguagesResponse;
-	static deserializeBinaryFromReader(
-		message: ListS2tLanguagesResponse,
-		reader: jspb.BinaryReader
-	): ListS2tLanguagesResponse;
+  getLanguagesList(): Array<string>;
+  setLanguagesList(value: Array<string>): ListS2tLanguagesResponse;
+  clearLanguagesList(): ListS2tLanguagesResponse;
+  addLanguages(value: string, index?: number): ListS2tLanguagesResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListS2tLanguagesResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ListS2tLanguagesResponse): ListS2tLanguagesResponse.AsObject;
+  static serializeBinaryToWriter(message: ListS2tLanguagesResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListS2tLanguagesResponse;
+  static deserializeBinaryFromReader(message: ListS2tLanguagesResponse, reader: jspb.BinaryReader): ListS2tLanguagesResponse;
 }
 
 export namespace ListS2tLanguagesResponse {
-	export type AsObject = {
-		languagesList: Array<string>;
-	};
+  export type AsObject = {
+    languagesList: Array<string>,
+  }
 }
 
 export class ListS2tDomainsRequest extends jspb.Message {
-	getLanguagesList(): Array<string>;
-	setLanguagesList(value: Array<string>): ListS2tDomainsRequest;
-	clearLanguagesList(): ListS2tDomainsRequest;
-	addLanguages(value: string, index?: number): ListS2tDomainsRequest;
+  getLanguagesList(): Array<string>;
+  setLanguagesList(value: Array<string>): ListS2tDomainsRequest;
+  clearLanguagesList(): ListS2tDomainsRequest;
+  addLanguages(value: string, index?: number): ListS2tDomainsRequest;
 
-	getPipelineOwnersList(): Array<string>;
-	setPipelineOwnersList(value: Array<string>): ListS2tDomainsRequest;
-	clearPipelineOwnersList(): ListS2tDomainsRequest;
-	addPipelineOwners(value: string, index?: number): ListS2tDomainsRequest;
+  getPipelineOwnersList(): Array<string>;
+  setPipelineOwnersList(value: Array<string>): ListS2tDomainsRequest;
+  clearPipelineOwnersList(): ListS2tDomainsRequest;
+  addPipelineOwners(value: string, index?: number): ListS2tDomainsRequest;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): ListS2tDomainsRequest.AsObject;
-	static toObject(includeInstance: boolean, msg: ListS2tDomainsRequest): ListS2tDomainsRequest.AsObject;
-	static serializeBinaryToWriter(message: ListS2tDomainsRequest, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): ListS2tDomainsRequest;
-	static deserializeBinaryFromReader(message: ListS2tDomainsRequest, reader: jspb.BinaryReader): ListS2tDomainsRequest;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListS2tDomainsRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ListS2tDomainsRequest): ListS2tDomainsRequest.AsObject;
+  static serializeBinaryToWriter(message: ListS2tDomainsRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListS2tDomainsRequest;
+  static deserializeBinaryFromReader(message: ListS2tDomainsRequest, reader: jspb.BinaryReader): ListS2tDomainsRequest;
 }
 
 export namespace ListS2tDomainsRequest {
-	export type AsObject = {
-		languagesList: Array<string>;
-		pipelineOwnersList: Array<string>;
-	};
+  export type AsObject = {
+    languagesList: Array<string>,
+    pipelineOwnersList: Array<string>,
+  }
 }
 
 export class ListS2tDomainsResponse extends jspb.Message {
-	getDomainsList(): Array<string>;
-	setDomainsList(value: Array<string>): ListS2tDomainsResponse;
-	clearDomainsList(): ListS2tDomainsResponse;
-	addDomains(value: string, index?: number): ListS2tDomainsResponse;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): ListS2tDomainsResponse.AsObject;
-	static toObject(includeInstance: boolean, msg: ListS2tDomainsResponse): ListS2tDomainsResponse.AsObject;
-	static serializeBinaryToWriter(message: ListS2tDomainsResponse, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): ListS2tDomainsResponse;
-	static deserializeBinaryFromReader(
-		message: ListS2tDomainsResponse,
-		reader: jspb.BinaryReader
-	): ListS2tDomainsResponse;
+  getDomainsList(): Array<string>;
+  setDomainsList(value: Array<string>): ListS2tDomainsResponse;
+  clearDomainsList(): ListS2tDomainsResponse;
+  addDomains(value: string, index?: number): ListS2tDomainsResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListS2tDomainsResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ListS2tDomainsResponse): ListS2tDomainsResponse.AsObject;
+  static serializeBinaryToWriter(message: ListS2tDomainsResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListS2tDomainsResponse;
+  static deserializeBinaryFromReader(message: ListS2tDomainsResponse, reader: jspb.BinaryReader): ListS2tDomainsResponse;
 }
 
 export namespace ListS2tDomainsResponse {
-	export type AsObject = {
-		domainsList: Array<string>;
-	};
+  export type AsObject = {
+    domainsList: Array<string>,
+  }
 }
 
-export class S2TGetServiceInfoResponse extends jspb.Message {
-	getVersion(): string;
-	setVersion(value: string): S2TGetServiceInfoResponse;
+export class S2tGetServiceInfoResponse extends jspb.Message {
+  getVersion(): string;
+  setVersion(value: string): S2tGetServiceInfoResponse;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): S2TGetServiceInfoResponse.AsObject;
-	static toObject(includeInstance: boolean, msg: S2TGetServiceInfoResponse): S2TGetServiceInfoResponse.AsObject;
-	static serializeBinaryToWriter(message: S2TGetServiceInfoResponse, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): S2TGetServiceInfoResponse;
-	static deserializeBinaryFromReader(
-		message: S2TGetServiceInfoResponse,
-		reader: jspb.BinaryReader
-	): S2TGetServiceInfoResponse;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tGetServiceInfoResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tGetServiceInfoResponse): S2tGetServiceInfoResponse.AsObject;
+  static serializeBinaryToWriter(message: S2tGetServiceInfoResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tGetServiceInfoResponse;
+  static deserializeBinaryFromReader(message: S2tGetServiceInfoResponse, reader: jspb.BinaryReader): S2tGetServiceInfoResponse;
 }
 
-export namespace S2TGetServiceInfoResponse {
-	export type AsObject = {
-		version: string;
-	};
+export namespace S2tGetServiceInfoResponse {
+  export type AsObject = {
+    version: string,
+  }
 }
 
 export class Speech2TextConfig extends jspb.Message {
-	getId(): string;
-	setId(value: string): Speech2TextConfig;
-
-	getDescription(): S2TDescription | undefined;
-	setDescription(value?: S2TDescription): Speech2TextConfig;
-	hasDescription(): boolean;
-	clearDescription(): Speech2TextConfig;
-
-	getActive(): boolean;
-	setActive(value: boolean): Speech2TextConfig;
-
-	getInference(): S2TInference | undefined;
-	setInference(value?: S2TInference): Speech2TextConfig;
-	hasInference(): boolean;
-	clearInference(): Speech2TextConfig;
-
-	getStreamingServer(): StreamingServer | undefined;
-	setStreamingServer(value?: StreamingServer): Speech2TextConfig;
-	hasStreamingServer(): boolean;
-	clearStreamingServer(): Speech2TextConfig;
-
-	getVoiceActivityDetection(): VoiceActivityDetection | undefined;
-	setVoiceActivityDetection(value?: VoiceActivityDetection): Speech2TextConfig;
-	hasVoiceActivityDetection(): boolean;
-	clearVoiceActivityDetection(): Speech2TextConfig;
-
-	getPostProcessing(): PostProcessing | undefined;
-	setPostProcessing(value?: PostProcessing): Speech2TextConfig;
-	hasPostProcessing(): boolean;
-	clearPostProcessing(): Speech2TextConfig;
-
-	getLogging(): Logging | undefined;
-	setLogging(value?: Logging): Speech2TextConfig;
-	hasLogging(): boolean;
-	clearLogging(): Speech2TextConfig;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): Speech2TextConfig.AsObject;
-	static toObject(includeInstance: boolean, msg: Speech2TextConfig): Speech2TextConfig.AsObject;
-	static serializeBinaryToWriter(message: Speech2TextConfig, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): Speech2TextConfig;
-	static deserializeBinaryFromReader(message: Speech2TextConfig, reader: jspb.BinaryReader): Speech2TextConfig;
+  getId(): string;
+  setId(value: string): Speech2TextConfig;
+
+  getDescription(): S2tDescription | undefined;
+  setDescription(value?: S2tDescription): Speech2TextConfig;
+  hasDescription(): boolean;
+  clearDescription(): Speech2TextConfig;
+
+  getActive(): boolean;
+  setActive(value: boolean): Speech2TextConfig;
+
+  getInference(): S2tInference | undefined;
+  setInference(value?: S2tInference): Speech2TextConfig;
+  hasInference(): boolean;
+  clearInference(): Speech2TextConfig;
+
+  getStreamingServer(): StreamingServer | undefined;
+  setStreamingServer(value?: StreamingServer): Speech2TextConfig;
+  hasStreamingServer(): boolean;
+  clearStreamingServer(): Speech2TextConfig;
+
+  getVoiceActivityDetection(): VoiceActivityDetection | undefined;
+  setVoiceActivityDetection(value?: VoiceActivityDetection): Speech2TextConfig;
+  hasVoiceActivityDetection(): boolean;
+  clearVoiceActivityDetection(): Speech2TextConfig;
+
+  getPostProcessing(): PostProcessing | undefined;
+  setPostProcessing(value?: PostProcessing): Speech2TextConfig;
+  hasPostProcessing(): boolean;
+  clearPostProcessing(): Speech2TextConfig;
+
+  getLogging(): Logging | undefined;
+  setLogging(value?: Logging): Speech2TextConfig;
+  hasLogging(): boolean;
+  clearLogging(): Speech2TextConfig;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Speech2TextConfig.AsObject;
+  static toObject(includeInstance: boolean, msg: Speech2TextConfig): Speech2TextConfig.AsObject;
+  static serializeBinaryToWriter(message: Speech2TextConfig, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Speech2TextConfig;
+  static deserializeBinaryFromReader(message: Speech2TextConfig, reader: jspb.BinaryReader): Speech2TextConfig;
 }
 
 export namespace Speech2TextConfig {
-	export type AsObject = {
-		id: string;
-		description?: S2TDescription.AsObject;
-		active: boolean;
-		inference?: S2TInference.AsObject;
-		streamingServer?: StreamingServer.AsObject;
-		voiceActivityDetection?: VoiceActivityDetection.AsObject;
-		postProcessing?: PostProcessing.AsObject;
-		logging?: Logging.AsObject;
-	};
-}
-
-export class S2TDescription extends jspb.Message {
-	getLanguage(): string;
-	setLanguage(value: string): S2TDescription;
-
-	getPipelineOwner(): string;
-	setPipelineOwner(value: string): S2TDescription;
-
-	getDomain(): string;
-	setDomain(value: string): S2TDescription;
-
-	getComments(): string;
-	setComments(value: string): S2TDescription;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): S2TDescription.AsObject;
-	static toObject(includeInstance: boolean, msg: S2TDescription): S2TDescription.AsObject;
-	static serializeBinaryToWriter(message: S2TDescription, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): S2TDescription;
-	static deserializeBinaryFromReader(message: S2TDescription, reader: jspb.BinaryReader): S2TDescription;
-}
-
-export namespace S2TDescription {
-	export type AsObject = {
-		language: string;
-		pipelineOwner: string;
-		domain: string;
-		comments: string;
-	};
-}
-
-export class S2TInference extends jspb.Message {
-	getAcousticModels(): AcousticModels | undefined;
-	setAcousticModels(value?: AcousticModels): S2TInference;
-	hasAcousticModels(): boolean;
-	clearAcousticModels(): S2TInference;
-
-	getLanguageModels(): LanguageModels | undefined;
-	setLanguageModels(value?: LanguageModels): S2TInference;
-	hasLanguageModels(): boolean;
-	clearLanguageModels(): S2TInference;
-
-	getInferenceBackend(): InferenceBackend;
-	setInferenceBackend(value: InferenceBackend): S2TInference;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): S2TInference.AsObject;
-	static toObject(includeInstance: boolean, msg: S2TInference): S2TInference.AsObject;
-	static serializeBinaryToWriter(message: S2TInference, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): S2TInference;
-	static deserializeBinaryFromReader(message: S2TInference, reader: jspb.BinaryReader): S2TInference;
-}
-
-export namespace S2TInference {
-	export type AsObject = {
-		acousticModels?: AcousticModels.AsObject;
-		languageModels?: LanguageModels.AsObject;
-		inferenceBackend: InferenceBackend;
-	};
+  export type AsObject = {
+    id: string,
+    description?: S2tDescription.AsObject,
+    active: boolean,
+    inference?: S2tInference.AsObject,
+    streamingServer?: StreamingServer.AsObject,
+    voiceActivityDetection?: VoiceActivityDetection.AsObject,
+    postProcessing?: PostProcessing.AsObject,
+    logging?: Logging.AsObject,
+  }
+}
+
+export class S2tDescription extends jspb.Message {
+  getLanguage(): string;
+  setLanguage(value: string): S2tDescription;
+
+  getPipelineOwner(): string;
+  setPipelineOwner(value: string): S2tDescription;
+
+  getDomain(): string;
+  setDomain(value: string): S2tDescription;
+
+  getComments(): string;
+  setComments(value: string): S2tDescription;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tDescription.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tDescription): S2tDescription.AsObject;
+  static serializeBinaryToWriter(message: S2tDescription, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tDescription;
+  static deserializeBinaryFromReader(message: S2tDescription, reader: jspb.BinaryReader): S2tDescription;
+}
+
+export namespace S2tDescription {
+  export type AsObject = {
+    language: string,
+    pipelineOwner: string,
+    domain: string,
+    comments: string,
+  }
+}
+
+export class S2tInference extends jspb.Message {
+  getAcousticModels(): AcousticModels | undefined;
+  setAcousticModels(value?: AcousticModels): S2tInference;
+  hasAcousticModels(): boolean;
+  clearAcousticModels(): S2tInference;
+
+  getLanguageModels(): LanguageModels | undefined;
+  setLanguageModels(value?: LanguageModels): S2tInference;
+  hasLanguageModels(): boolean;
+  clearLanguageModels(): S2tInference;
+
+  getInferenceBackend(): InferenceBackend;
+  setInferenceBackend(value: InferenceBackend): S2tInference;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tInference.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tInference): S2tInference.AsObject;
+  static serializeBinaryToWriter(message: S2tInference, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tInference;
+  static deserializeBinaryFromReader(message: S2tInference, reader: jspb.BinaryReader): S2tInference;
+}
+
+export namespace S2tInference {
+  export type AsObject = {
+    acousticModels?: AcousticModels.AsObject,
+    languageModels?: LanguageModels.AsObject,
+    inferenceBackend: InferenceBackend,
+  }
 }
 
 export class AcousticModels extends jspb.Message {
-	getType(): string;
-	setType(value: string): AcousticModels;
+  getType(): string;
+  setType(value: string): AcousticModels;
+
+  getWav2vec(): Wav2Vec | undefined;
+  setWav2vec(value?: Wav2Vec): AcousticModels;
+  hasWav2vec(): boolean;
+  clearWav2vec(): AcousticModels;
+
+  getWav2vecTriton(): Wav2VecTriton | undefined;
+  setWav2vecTriton(value?: Wav2VecTriton): AcousticModels;
+  hasWav2vecTriton(): boolean;
+  clearWav2vecTriton(): AcousticModels;
+
+  getWhisper(): Whisper | undefined;
+  setWhisper(value?: Whisper): AcousticModels;
+  hasWhisper(): boolean;
+  clearWhisper(): AcousticModels;
+
+  getWhisperTriton(): WhisperTriton | undefined;
+  setWhisperTriton(value?: WhisperTriton): AcousticModels;
+  hasWhisperTriton(): boolean;
+  clearWhisperTriton(): AcousticModels;
+
+  getS2tCloudServiceAmazon(): S2tCloudServiceAmazon | undefined;
+  setS2tCloudServiceAmazon(value?: S2tCloudServiceAmazon): AcousticModels;
+  hasS2tCloudServiceAmazon(): boolean;
+  clearS2tCloudServiceAmazon(): AcousticModels;
+
+  getS2tCloudServiceDeepgram(): S2tCloudServiceDeepgram | undefined;
+  setS2tCloudServiceDeepgram(value?: S2tCloudServiceDeepgram): AcousticModels;
+  hasS2tCloudServiceDeepgram(): boolean;
+  clearS2tCloudServiceDeepgram(): AcousticModels;
+
+  getS2tCloudServiceGoogle(): S2tCloudServiceGoogle | undefined;
+  setS2tCloudServiceGoogle(value?: S2tCloudServiceGoogle): AcousticModels;
+  hasS2tCloudServiceGoogle(): boolean;
+  clearS2tCloudServiceGoogle(): AcousticModels;
+
+  getS2tCloudServiceMicrosoft(): S2tCloudServiceMicrosoft | undefined;
+  setS2tCloudServiceMicrosoft(value?: S2tCloudServiceMicrosoft): AcousticModels;
+  hasS2tCloudServiceMicrosoft(): boolean;
+  clearS2tCloudServiceMicrosoft(): AcousticModels;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AcousticModels.AsObject;
+  static toObject(includeInstance: boolean, msg: AcousticModels): AcousticModels.AsObject;
+  static serializeBinaryToWriter(message: AcousticModels, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AcousticModels;
+  static deserializeBinaryFromReader(message: AcousticModels, reader: jspb.BinaryReader): AcousticModels;
+}
+
+export namespace AcousticModels {
+  export type AsObject = {
+    type: string,
+    wav2vec?: Wav2Vec.AsObject,
+    wav2vecTriton?: Wav2VecTriton.AsObject,
+    whisper?: Whisper.AsObject,
+    whisperTriton?: WhisperTriton.AsObject,
+    s2tCloudServiceAmazon?: S2tCloudServiceAmazon.AsObject,
+    s2tCloudServiceDeepgram?: S2tCloudServiceDeepgram.AsObject,
+    s2tCloudServiceGoogle?: S2tCloudServiceGoogle.AsObject,
+    s2tCloudServiceMicrosoft?: S2tCloudServiceMicrosoft.AsObject,
+  }
+}
 
-	getWav2vec(): Wav2Vec | undefined;
-	setWav2vec(value?: Wav2Vec): AcousticModels;
-	hasWav2vec(): boolean;
-	clearWav2vec(): AcousticModels;
+export class S2tCloudServiceAmazon extends jspb.Message {
+  getLanguage(): string;
+  setLanguage(value: string): S2tCloudServiceAmazon;
 
-	getWav2vecTriton(): Wav2VecTriton | undefined;
-	setWav2vecTriton(value?: Wav2VecTriton): AcousticModels;
-	hasWav2vecTriton(): boolean;
-	clearWav2vecTriton(): AcousticModels;
+  getStreamingAvailable(): boolean;
+  setStreamingAvailable(value: boolean): S2tCloudServiceAmazon;
 
-	getWhisper(): Whisper | undefined;
-	setWhisper(value?: Whisper): AcousticModels;
-	hasWhisper(): boolean;
-	clearWhisper(): AcousticModels;
+  getEnablePartialResultsStabilization(): boolean;
+  setEnablePartialResultsStabilization(value: boolean): S2tCloudServiceAmazon;
 
-	getWhisperTriton(): WhisperTriton | undefined;
-	setWhisperTriton(value?: WhisperTriton): AcousticModels;
-	hasWhisperTriton(): boolean;
-	clearWhisperTriton(): AcousticModels;
+  getPartialResultsStability(): string;
+  setPartialResultsStability(value: string): S2tCloudServiceAmazon;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): AcousticModels.AsObject;
-	static toObject(includeInstance: boolean, msg: AcousticModels): AcousticModels.AsObject;
-	static serializeBinaryToWriter(message: AcousticModels, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): AcousticModels;
-	static deserializeBinaryFromReader(message: AcousticModels, reader: jspb.BinaryReader): AcousticModels;
+  getLanguageModelName(): string;
+  setLanguageModelName(value: string): S2tCloudServiceAmazon;
+
+  getVocabularyName(): string;
+  setVocabularyName(value: string): S2tCloudServiceAmazon;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tCloudServiceAmazon.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tCloudServiceAmazon): S2tCloudServiceAmazon.AsObject;
+  static serializeBinaryToWriter(message: S2tCloudServiceAmazon, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tCloudServiceAmazon;
+  static deserializeBinaryFromReader(message: S2tCloudServiceAmazon, reader: jspb.BinaryReader): S2tCloudServiceAmazon;
 }
 
-export namespace AcousticModels {
-	export type AsObject = {
-		type: string;
-		wav2vec?: Wav2Vec.AsObject;
-		wav2vecTriton?: Wav2VecTriton.AsObject;
-		whisper?: Whisper.AsObject;
-		whisperTriton?: WhisperTriton.AsObject;
-	};
+export namespace S2tCloudServiceAmazon {
+  export type AsObject = {
+    language: string,
+    streamingAvailable: boolean,
+    enablePartialResultsStabilization: boolean,
+    partialResultsStability: string,
+    languageModelName: string,
+    vocabularyName: string,
+  }
+}
+
+export class S2tCloudServiceDeepgram extends jspb.Message {
+  getModelName(): string;
+  setModelName(value: string): S2tCloudServiceDeepgram;
+
+  getLanguage(): string;
+  setLanguage(value: string): S2tCloudServiceDeepgram;
+
+  getPunctuate(): boolean;
+  setPunctuate(value: boolean): S2tCloudServiceDeepgram;
+
+  getSmartFormat(): boolean;
+  setSmartFormat(value: boolean): S2tCloudServiceDeepgram;
+
+  getNumerals(): boolean;
+  setNumerals(value: boolean): S2tCloudServiceDeepgram;
+
+  getMeasurements(): boolean;
+  setMeasurements(value: boolean): S2tCloudServiceDeepgram;
+
+  getDictation(): boolean;
+  setDictation(value: boolean): S2tCloudServiceDeepgram;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tCloudServiceDeepgram.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tCloudServiceDeepgram): S2tCloudServiceDeepgram.AsObject;
+  static serializeBinaryToWriter(message: S2tCloudServiceDeepgram, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tCloudServiceDeepgram;
+  static deserializeBinaryFromReader(message: S2tCloudServiceDeepgram, reader: jspb.BinaryReader): S2tCloudServiceDeepgram;
+}
+
+export namespace S2tCloudServiceDeepgram {
+  export type AsObject = {
+    modelName: string,
+    language: string,
+    punctuate: boolean,
+    smartFormat: boolean,
+    numerals: boolean,
+    measurements: boolean,
+    dictation: boolean,
+  }
+}
+
+export class S2tCloudServiceGoogle extends jspb.Message {
+  getModelName(): string;
+  setModelName(value: string): S2tCloudServiceGoogle;
+
+  getLanguage(): string;
+  setLanguage(value: string): S2tCloudServiceGoogle;
+
+  getEnableAutomaticPunctuation(): boolean;
+  setEnableAutomaticPunctuation(value: boolean): S2tCloudServiceGoogle;
+
+  getEnableWordTimeOffsets(): boolean;
+  setEnableWordTimeOffsets(value: boolean): S2tCloudServiceGoogle;
+
+  getEnableWordConfidence(): boolean;
+  setEnableWordConfidence(value: boolean): S2tCloudServiceGoogle;
+
+  getTranscriptNormalization(): boolean;
+  setTranscriptNormalization(value: boolean): S2tCloudServiceGoogle;
+
+  getMaxAlternatives(): number;
+  setMaxAlternatives(value: number): S2tCloudServiceGoogle;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tCloudServiceGoogle.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tCloudServiceGoogle): S2tCloudServiceGoogle.AsObject;
+  static serializeBinaryToWriter(message: S2tCloudServiceGoogle, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tCloudServiceGoogle;
+  static deserializeBinaryFromReader(message: S2tCloudServiceGoogle, reader: jspb.BinaryReader): S2tCloudServiceGoogle;
+}
+
+export namespace S2tCloudServiceGoogle {
+  export type AsObject = {
+    modelName: string,
+    language: string,
+    enableAutomaticPunctuation: boolean,
+    enableWordTimeOffsets: boolean,
+    enableWordConfidence: boolean,
+    transcriptNormalization: boolean,
+    maxAlternatives: number,
+  }
+}
+
+export class S2tCloudServiceMicrosoft extends jspb.Message {
+  getLanguage(): string;
+  setLanguage(value: string): S2tCloudServiceMicrosoft;
+
+  getUseFastTranscriptionApi(): boolean;
+  setUseFastTranscriptionApi(value: boolean): S2tCloudServiceMicrosoft;
+
+  getUseDetailedOutputFormat(): boolean;
+  setUseDetailedOutputFormat(value: boolean): S2tCloudServiceMicrosoft;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tCloudServiceMicrosoft.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tCloudServiceMicrosoft): S2tCloudServiceMicrosoft.AsObject;
+  static serializeBinaryToWriter(message: S2tCloudServiceMicrosoft, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tCloudServiceMicrosoft;
+  static deserializeBinaryFromReader(message: S2tCloudServiceMicrosoft, reader: jspb.BinaryReader): S2tCloudServiceMicrosoft;
+}
+
+export namespace S2tCloudServiceMicrosoft {
+  export type AsObject = {
+    language: string,
+    useFastTranscriptionApi: boolean,
+    useDetailedOutputFormat: boolean,
+  }
 }
 
 export class Whisper extends jspb.Message {
-	getModelPath(): string;
-	setModelPath(value: string): Whisper;
+  getModelPath(): string;
+  setModelPath(value: string): Whisper;
 
-	getUseGpu(): boolean;
-	setUseGpu(value: boolean): Whisper;
+  getUseGpu(): boolean;
+  setUseGpu(value: boolean): Whisper;
 
-	getLanguage(): string;
-	setLanguage(value: string): Whisper;
+  getLanguage(): string;
+  setLanguage(value: string): Whisper;
 
-	getTask(): string;
-	setTask(value: string): Whisper;
+  getTask(): string;
+  setTask(value: string): Whisper;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): Whisper.AsObject;
-	static toObject(includeInstance: boolean, msg: Whisper): Whisper.AsObject;
-	static serializeBinaryToWriter(message: Whisper, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): Whisper;
-	static deserializeBinaryFromReader(message: Whisper, reader: jspb.BinaryReader): Whisper;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Whisper.AsObject;
+  static toObject(includeInstance: boolean, msg: Whisper): Whisper.AsObject;
+  static serializeBinaryToWriter(message: Whisper, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Whisper;
+  static deserializeBinaryFromReader(message: Whisper, reader: jspb.BinaryReader): Whisper;
 }
 
 export namespace Whisper {
-	export type AsObject = {
-		modelPath: string;
-		useGpu: boolean;
-		language: string;
-		task: string;
-	};
+  export type AsObject = {
+    modelPath: string,
+    useGpu: boolean,
+    language: string,
+    task: string,
+  }
 }
 
 export class WhisperTriton extends jspb.Message {
-	getProcessorPath(): string;
-	setProcessorPath(value: string): WhisperTriton;
+  getProcessorPath(): string;
+  setProcessorPath(value: string): WhisperTriton;
 
-	getTritonModelName(): string;
-	setTritonModelName(value: string): WhisperTriton;
+  getTritonModelName(): string;
+  setTritonModelName(value: string): WhisperTriton;
 
-	getTritonModelVersion(): string;
-	setTritonModelVersion(value: string): WhisperTriton;
+  getTritonModelVersion(): string;
+  setTritonModelVersion(value: string): WhisperTriton;
 
-	getCheckStatusTimeout(): number;
-	setCheckStatusTimeout(value: number): WhisperTriton;
+  getCheckStatusTimeout(): number;
+  setCheckStatusTimeout(value: number): WhisperTriton;
 
-	getLanguage(): string;
-	setLanguage(value: string): WhisperTriton;
+  getLanguage(): string;
+  setLanguage(value: string): WhisperTriton;
 
-	getTask(): string;
-	setTask(value: string): WhisperTriton;
+  getTask(): string;
+  setTask(value: string): WhisperTriton;
 
-	getTritonServerHost(): string;
-	setTritonServerHost(value: string): WhisperTriton;
+  getTritonServerHost(): string;
+  setTritonServerHost(value: string): WhisperTriton;
 
-	getTritonServerPort(): number;
-	setTritonServerPort(value: number): WhisperTriton;
+  getTritonServerPort(): number;
+  setTritonServerPort(value: number): WhisperTriton;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): WhisperTriton.AsObject;
-	static toObject(includeInstance: boolean, msg: WhisperTriton): WhisperTriton.AsObject;
-	static serializeBinaryToWriter(message: WhisperTriton, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): WhisperTriton;
-	static deserializeBinaryFromReader(message: WhisperTriton, reader: jspb.BinaryReader): WhisperTriton;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): WhisperTriton.AsObject;
+  static toObject(includeInstance: boolean, msg: WhisperTriton): WhisperTriton.AsObject;
+  static serializeBinaryToWriter(message: WhisperTriton, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): WhisperTriton;
+  static deserializeBinaryFromReader(message: WhisperTriton, reader: jspb.BinaryReader): WhisperTriton;
 }
 
 export namespace WhisperTriton {
-	export type AsObject = {
-		processorPath: string;
-		tritonModelName: string;
-		tritonModelVersion: string;
-		checkStatusTimeout: number;
-		language: string;
-		task: string;
-		tritonServerHost: string;
-		tritonServerPort: number;
-	};
+  export type AsObject = {
+    processorPath: string,
+    tritonModelName: string,
+    tritonModelVersion: string,
+    checkStatusTimeout: number,
+    language: string,
+    task: string,
+    tritonServerHost: string,
+    tritonServerPort: number,
+  }
 }
 
 export class Wav2Vec extends jspb.Message {
-	getModelPath(): string;
-	setModelPath(value: string): Wav2Vec;
+  getModelPath(): string;
+  setModelPath(value: string): Wav2Vec;
 
-	getUseGpu(): boolean;
-	setUseGpu(value: boolean): Wav2Vec;
+  getUseGpu(): boolean;
+  setUseGpu(value: boolean): Wav2Vec;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): Wav2Vec.AsObject;
-	static toObject(includeInstance: boolean, msg: Wav2Vec): Wav2Vec.AsObject;
-	static serializeBinaryToWriter(message: Wav2Vec, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): Wav2Vec;
-	static deserializeBinaryFromReader(message: Wav2Vec, reader: jspb.BinaryReader): Wav2Vec;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Wav2Vec.AsObject;
+  static toObject(includeInstance: boolean, msg: Wav2Vec): Wav2Vec.AsObject;
+  static serializeBinaryToWriter(message: Wav2Vec, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Wav2Vec;
+  static deserializeBinaryFromReader(message: Wav2Vec, reader: jspb.BinaryReader): Wav2Vec;
 }
 
 export namespace Wav2Vec {
-	export type AsObject = {
-		modelPath: string;
-		useGpu: boolean;
-	};
+  export type AsObject = {
+    modelPath: string,
+    useGpu: boolean,
+  }
 }
 
 export class Wav2VecTriton extends jspb.Message {
-	getProcessorPath(): string;
-	setProcessorPath(value: string): Wav2VecTriton;
+  getProcessorPath(): string;
+  setProcessorPath(value: string): Wav2VecTriton;
 
-	getTritonModelName(): string;
-	setTritonModelName(value: string): Wav2VecTriton;
+  getTritonModelName(): string;
+  setTritonModelName(value: string): Wav2VecTriton;
 
-	getTritonModelVersion(): string;
-	setTritonModelVersion(value: string): Wav2VecTriton;
+  getTritonModelVersion(): string;
+  setTritonModelVersion(value: string): Wav2VecTriton;
 
-	getCheckStatusTimeout(): number;
-	setCheckStatusTimeout(value: number): Wav2VecTriton;
+  getCheckStatusTimeout(): number;
+  setCheckStatusTimeout(value: number): Wav2VecTriton;
 
-	getTritonServerHost(): string;
-	setTritonServerHost(value: string): Wav2VecTriton;
+  getTritonServerHost(): string;
+  setTritonServerHost(value: string): Wav2VecTriton;
 
-	getTritonServerPort(): number;
-	setTritonServerPort(value: number): Wav2VecTriton;
+  getTritonServerPort(): number;
+  setTritonServerPort(value: number): Wav2VecTriton;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): Wav2VecTriton.AsObject;
-	static toObject(includeInstance: boolean, msg: Wav2VecTriton): Wav2VecTriton.AsObject;
-	static serializeBinaryToWriter(message: Wav2VecTriton, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): Wav2VecTriton;
-	static deserializeBinaryFromReader(message: Wav2VecTriton, reader: jspb.BinaryReader): Wav2VecTriton;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Wav2VecTriton.AsObject;
+  static toObject(includeInstance: boolean, msg: Wav2VecTriton): Wav2VecTriton.AsObject;
+  static serializeBinaryToWriter(message: Wav2VecTriton, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Wav2VecTriton;
+  static deserializeBinaryFromReader(message: Wav2VecTriton, reader: jspb.BinaryReader): Wav2VecTriton;
 }
 
 export namespace Wav2VecTriton {
-	export type AsObject = {
-		processorPath: string;
-		tritonModelName: string;
-		tritonModelVersion: string;
-		checkStatusTimeout: number;
-		tritonServerHost: string;
-		tritonServerPort: number;
-	};
+  export type AsObject = {
+    processorPath: string,
+    tritonModelName: string,
+    tritonModelVersion: string,
+    checkStatusTimeout: number,
+    tritonServerHost: string,
+    tritonServerPort: number,
+  }
 }
 
 export class PtFiles extends jspb.Message {
-	getPath(): string;
-	setPath(value: string): PtFiles;
+  getPath(): string;
+  setPath(value: string): PtFiles;
 
-	getStep(): string;
-	setStep(value: string): PtFiles;
+  getStep(): string;
+  setStep(value: string): PtFiles;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): PtFiles.AsObject;
-	static toObject(includeInstance: boolean, msg: PtFiles): PtFiles.AsObject;
-	static serializeBinaryToWriter(message: PtFiles, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): PtFiles;
-	static deserializeBinaryFromReader(message: PtFiles, reader: jspb.BinaryReader): PtFiles;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PtFiles.AsObject;
+  static toObject(includeInstance: boolean, msg: PtFiles): PtFiles.AsObject;
+  static serializeBinaryToWriter(message: PtFiles, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PtFiles;
+  static deserializeBinaryFromReader(message: PtFiles, reader: jspb.BinaryReader): PtFiles;
 }
 
 export namespace PtFiles {
-	export type AsObject = {
-		path: string;
-		step: string;
-	};
+  export type AsObject = {
+    path: string,
+    step: string,
+  }
 }
 
 export class CkptFile extends jspb.Message {
-	getPath(): string;
-	setPath(value: string): CkptFile;
+  getPath(): string;
+  setPath(value: string): CkptFile;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): CkptFile.AsObject;
-	static toObject(includeInstance: boolean, msg: CkptFile): CkptFile.AsObject;
-	static serializeBinaryToWriter(message: CkptFile, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): CkptFile;
-	static deserializeBinaryFromReader(message: CkptFile, reader: jspb.BinaryReader): CkptFile;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CkptFile.AsObject;
+  static toObject(includeInstance: boolean, msg: CkptFile): CkptFile.AsObject;
+  static serializeBinaryToWriter(message: CkptFile, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CkptFile;
+  static deserializeBinaryFromReader(message: CkptFile, reader: jspb.BinaryReader): CkptFile;
 }
 
 export namespace CkptFile {
-	export type AsObject = {
-		path: string;
-	};
+  export type AsObject = {
+    path: string,
+  }
 }
 
 export class LanguageModels extends jspb.Message {
-	getPath(): string;
-	setPath(value: string): LanguageModels;
+  getPath(): string;
+  setPath(value: string): LanguageModels;
 
-	getBeamSize(): number;
-	setBeamSize(value: number): LanguageModels;
+  getBeamSize(): number;
+  setBeamSize(value: number): LanguageModels;
 
-	getDefaultLm(): string;
-	setDefaultLm(value: string): LanguageModels;
+  getDefaultLm(): string;
+  setDefaultLm(value: string): LanguageModels;
 
-	getBeamSearchScorerAlpha(): number;
-	setBeamSearchScorerAlpha(value: number): LanguageModels;
+  getBeamSearchScorerAlpha(): number;
+  setBeamSearchScorerAlpha(value: number): LanguageModels;
 
-	getBeamSearchScorerBeta(): number;
-	setBeamSearchScorerBeta(value: number): LanguageModels;
+  getBeamSearchScorerBeta(): number;
+  setBeamSearchScorerBeta(value: number): LanguageModels;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): LanguageModels.AsObject;
-	static toObject(includeInstance: boolean, msg: LanguageModels): LanguageModels.AsObject;
-	static serializeBinaryToWriter(message: LanguageModels, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): LanguageModels;
-	static deserializeBinaryFromReader(message: LanguageModels, reader: jspb.BinaryReader): LanguageModels;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LanguageModels.AsObject;
+  static toObject(includeInstance: boolean, msg: LanguageModels): LanguageModels.AsObject;
+  static serializeBinaryToWriter(message: LanguageModels, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LanguageModels;
+  static deserializeBinaryFromReader(message: LanguageModels, reader: jspb.BinaryReader): LanguageModels;
 }
 
 export namespace LanguageModels {
-	export type AsObject = {
-		path: string;
-		beamSize: number;
-		defaultLm: string;
-		beamSearchScorerAlpha: number;
-		beamSearchScorerBeta: number;
-	};
+  export type AsObject = {
+    path: string,
+    beamSize: number,
+    defaultLm: string,
+    beamSearchScorerAlpha: number,
+    beamSearchScorerBeta: number,
+  }
 }
 
 export class StreamingServer extends jspb.Message {
-	getHost(): string;
-	setHost(value: string): StreamingServer;
+  getHost(): string;
+  setHost(value: string): StreamingServer;
 
-	getPort(): number;
-	setPort(value: number): StreamingServer;
+  getPort(): number;
+  setPort(value: number): StreamingServer;
 
-	getOutputStyle(): string;
-	setOutputStyle(value: string): StreamingServer;
+  getOutputStyle(): string;
+  setOutputStyle(value: string): StreamingServer;
 
-	getStreamingSpeechRecognition(): StreamingSpeechRecognition | undefined;
-	setStreamingSpeechRecognition(value?: StreamingSpeechRecognition): StreamingServer;
-	hasStreamingSpeechRecognition(): boolean;
-	clearStreamingSpeechRecognition(): StreamingServer;
+  getStreamingSpeechRecognition(): StreamingSpeechRecognition | undefined;
+  setStreamingSpeechRecognition(value?: StreamingSpeechRecognition): StreamingServer;
+  hasStreamingSpeechRecognition(): boolean;
+  clearStreamingSpeechRecognition(): StreamingServer;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): StreamingServer.AsObject;
-	static toObject(includeInstance: boolean, msg: StreamingServer): StreamingServer.AsObject;
-	static serializeBinaryToWriter(message: StreamingServer, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): StreamingServer;
-	static deserializeBinaryFromReader(message: StreamingServer, reader: jspb.BinaryReader): StreamingServer;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StreamingServer.AsObject;
+  static toObject(includeInstance: boolean, msg: StreamingServer): StreamingServer.AsObject;
+  static serializeBinaryToWriter(message: StreamingServer, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StreamingServer;
+  static deserializeBinaryFromReader(message: StreamingServer, reader: jspb.BinaryReader): StreamingServer;
 }
 
 export namespace StreamingServer {
-	export type AsObject = {
-		host: string;
-		port: number;
-		outputStyle: string;
-		streamingSpeechRecognition?: StreamingSpeechRecognition.AsObject;
-	};
+  export type AsObject = {
+    host: string,
+    port: number,
+    outputStyle: string,
+    streamingSpeechRecognition?: StreamingSpeechRecognition.AsObject,
+  }
 }
 
 export class StreamingSpeechRecognition extends jspb.Message {
-	getTranscribeNotFinal(): boolean;
-	setTranscribeNotFinal(value: boolean): StreamingSpeechRecognition;
+  getTranscribeNotFinal(): boolean;
+  setTranscribeNotFinal(value: boolean): StreamingSpeechRecognition;
+
+  getDecodingMethod(): string;
+  setDecodingMethod(value: string): StreamingSpeechRecognition;
 
-	getDecodingMethod(): string;
-	setDecodingMethod(value: string): StreamingSpeechRecognition;
+  getSamplingRate(): number;
+  setSamplingRate(value: number): StreamingSpeechRecognition;
 
-	getSamplingRate(): number;
-	setSamplingRate(value: number): StreamingSpeechRecognition;
+  getMinAudioChunkSize(): number;
+  setMinAudioChunkSize(value: number): StreamingSpeechRecognition;
 
-	getMinAudioChunkSize(): number;
-	setMinAudioChunkSize(value: number): StreamingSpeechRecognition;
+  getNextChunkTimeout(): number;
+  setNextChunkTimeout(value: number): StreamingSpeechRecognition;
 
-	getNextChunkTimeout(): number;
-	setNextChunkTimeout(value: number): StreamingSpeechRecognition;
+  getTurnDetection(): TurnDetectionOptions | undefined;
+  setTurnDetection(value?: TurnDetectionOptions): StreamingSpeechRecognition;
+  hasTurnDetection(): boolean;
+  clearTurnDetection(): StreamingSpeechRecognition;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): StreamingSpeechRecognition.AsObject;
-	static toObject(includeInstance: boolean, msg: StreamingSpeechRecognition): StreamingSpeechRecognition.AsObject;
-	static serializeBinaryToWriter(message: StreamingSpeechRecognition, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): StreamingSpeechRecognition;
-	static deserializeBinaryFromReader(
-		message: StreamingSpeechRecognition,
-		reader: jspb.BinaryReader
-	): StreamingSpeechRecognition;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StreamingSpeechRecognition.AsObject;
+  static toObject(includeInstance: boolean, msg: StreamingSpeechRecognition): StreamingSpeechRecognition.AsObject;
+  static serializeBinaryToWriter(message: StreamingSpeechRecognition, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StreamingSpeechRecognition;
+  static deserializeBinaryFromReader(message: StreamingSpeechRecognition, reader: jspb.BinaryReader): StreamingSpeechRecognition;
 }
 
 export namespace StreamingSpeechRecognition {
-	export type AsObject = {
-		transcribeNotFinal: boolean;
-		decodingMethod: string;
-		samplingRate: number;
-		minAudioChunkSize: number;
-		nextChunkTimeout: number;
-	};
+  export type AsObject = {
+    transcribeNotFinal: boolean,
+    decodingMethod: string,
+    samplingRate: number,
+    minAudioChunkSize: number,
+    nextChunkTimeout: number,
+    turnDetection?: TurnDetectionOptions.AsObject,
+  }
+}
+
+export class TurnDetectionOptions extends jspb.Message {
+  getActive(): boolean;
+  setActive(value: boolean): TurnDetectionOptions;
+  hasActive(): boolean;
+  clearActive(): TurnDetectionOptions;
+
+  getFullUtteranceDeployment(): boolean;
+  setFullUtteranceDeployment(value: boolean): TurnDetectionOptions;
+  hasFullUtteranceDeployment(): boolean;
+  clearFullUtteranceDeployment(): TurnDetectionOptions;
+
+  getLlmHost(): string;
+  setLlmHost(value: string): TurnDetectionOptions;
+  hasLlmHost(): boolean;
+  clearLlmHost(): TurnDetectionOptions;
+
+  getLlmPort(): number;
+  setLlmPort(value: number): TurnDetectionOptions;
+  hasLlmPort(): boolean;
+  clearLlmPort(): TurnDetectionOptions;
+
+  getLlmRequestTimeout(): number;
+  setLlmRequestTimeout(value: number): TurnDetectionOptions;
+  hasLlmRequestTimeout(): boolean;
+  clearLlmRequestTimeout(): TurnDetectionOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TurnDetectionOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: TurnDetectionOptions): TurnDetectionOptions.AsObject;
+  static serializeBinaryToWriter(message: TurnDetectionOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TurnDetectionOptions;
+  static deserializeBinaryFromReader(message: TurnDetectionOptions, reader: jspb.BinaryReader): TurnDetectionOptions;
+}
+
+export namespace TurnDetectionOptions {
+  export type AsObject = {
+    active?: boolean,
+    fullUtteranceDeployment?: boolean,
+    llmHost?: string,
+    llmPort?: number,
+    llmRequestTimeout?: number,
+  }
+
+  export enum ActiveCase { 
+    _ACTIVE_NOT_SET = 0,
+    ACTIVE = 1,
+  }
+
+  export enum FullUtteranceDeploymentCase { 
+    _FULL_UTTERANCE_DEPLOYMENT_NOT_SET = 0,
+    FULL_UTTERANCE_DEPLOYMENT = 2,
+  }
+
+  export enum LlmHostCase { 
+    _LLM_HOST_NOT_SET = 0,
+    LLM_HOST = 3,
+  }
+
+  export enum LlmPortCase { 
+    _LLM_PORT_NOT_SET = 0,
+    LLM_PORT = 4,
+  }
+
+  export enum LlmRequestTimeoutCase { 
+    _LLM_REQUEST_TIMEOUT_NOT_SET = 0,
+    LLM_REQUEST_TIMEOUT = 5,
+  }
 }
 
 export class VoiceActivityDetection extends jspb.Message {
-	getActive(): string;
-	setActive(value: string): VoiceActivityDetection;
+  getActive(): string;
+  setActive(value: string): VoiceActivityDetection;
 
-	getSamplingRate(): number;
-	setSamplingRate(value: number): VoiceActivityDetection;
+  getSamplingRate(): number;
+  setSamplingRate(value: number): VoiceActivityDetection;
 
-	getPyannote(): Pyannote | undefined;
-	setPyannote(value?: Pyannote): VoiceActivityDetection;
-	hasPyannote(): boolean;
-	clearPyannote(): VoiceActivityDetection;
+  getPyannote(): Pyannote | undefined;
+  setPyannote(value?: Pyannote): VoiceActivityDetection;
+  hasPyannote(): boolean;
+  clearPyannote(): VoiceActivityDetection;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): VoiceActivityDetection.AsObject;
-	static toObject(includeInstance: boolean, msg: VoiceActivityDetection): VoiceActivityDetection.AsObject;
-	static serializeBinaryToWriter(message: VoiceActivityDetection, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): VoiceActivityDetection;
-	static deserializeBinaryFromReader(
-		message: VoiceActivityDetection,
-		reader: jspb.BinaryReader
-	): VoiceActivityDetection;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): VoiceActivityDetection.AsObject;
+  static toObject(includeInstance: boolean, msg: VoiceActivityDetection): VoiceActivityDetection.AsObject;
+  static serializeBinaryToWriter(message: VoiceActivityDetection, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): VoiceActivityDetection;
+  static deserializeBinaryFromReader(message: VoiceActivityDetection, reader: jspb.BinaryReader): VoiceActivityDetection;
 }
 
 export namespace VoiceActivityDetection {
-	export type AsObject = {
-		active: string;
-		samplingRate: number;
-		pyannote?: Pyannote.AsObject;
-	};
+  export type AsObject = {
+    active: string,
+    samplingRate: number,
+    pyannote?: Pyannote.AsObject,
+  }
 }
 
 export class Pyannote extends jspb.Message {
-	getModelName(): string;
-	setModelName(value: string): Pyannote;
+  getModelName(): string;
+  setModelName(value: string): Pyannote;
 
-	getMinAudioSize(): number;
-	setMinAudioSize(value: number): Pyannote;
+  getMinAudioSize(): number;
+  setMinAudioSize(value: number): Pyannote;
 
-	getMinDurationOff(): number;
-	setMinDurationOff(value: number): Pyannote;
+  getMinDurationOff(): number;
+  setMinDurationOff(value: number): Pyannote;
 
-	getMinDurationOn(): number;
-	setMinDurationOn(value: number): Pyannote;
+  getMinDurationOn(): number;
+  setMinDurationOn(value: number): Pyannote;
 
-	getTritonServerHost(): string;
-	setTritonServerHost(value: string): Pyannote;
+  getTritonServerHost(): string;
+  setTritonServerHost(value: string): Pyannote;
 
-	getTritonServerPort(): number;
-	setTritonServerPort(value: number): Pyannote;
+  getTritonServerPort(): number;
+  setTritonServerPort(value: number): Pyannote;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): Pyannote.AsObject;
-	static toObject(includeInstance: boolean, msg: Pyannote): Pyannote.AsObject;
-	static serializeBinaryToWriter(message: Pyannote, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): Pyannote;
-	static deserializeBinaryFromReader(message: Pyannote, reader: jspb.BinaryReader): Pyannote;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Pyannote.AsObject;
+  static toObject(includeInstance: boolean, msg: Pyannote): Pyannote.AsObject;
+  static serializeBinaryToWriter(message: Pyannote, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Pyannote;
+  static deserializeBinaryFromReader(message: Pyannote, reader: jspb.BinaryReader): Pyannote;
 }
 
 export namespace Pyannote {
-	export type AsObject = {
-		modelName: string;
-		minAudioSize: number;
-		minDurationOff: number;
-		minDurationOn: number;
-		tritonServerHost: string;
-		tritonServerPort: number;
-	};
+  export type AsObject = {
+    modelName: string,
+    minAudioSize: number,
+    minDurationOff: number,
+    minDurationOn: number,
+    tritonServerHost: string,
+    tritonServerPort: number,
+  }
 }
 
 export class PostProcessing extends jspb.Message {
-	getPipelineList(): Array<string>;
-	setPipelineList(value: Array<string>): PostProcessing;
-	clearPipelineList(): PostProcessing;
-	addPipeline(value: string, index?: number): PostProcessing;
+  getPipelineList(): Array<string>;
+  setPipelineList(value: Array<string>): PostProcessing;
+  clearPipelineList(): PostProcessing;
+  addPipeline(value: string, index?: number): PostProcessing;
 
-	getPostProcessors(): PostProcessors | undefined;
-	setPostProcessors(value?: PostProcessors): PostProcessing;
-	hasPostProcessors(): boolean;
-	clearPostProcessors(): PostProcessing;
+  getPostProcessors(): PostProcessors | undefined;
+  setPostProcessors(value?: PostProcessors): PostProcessing;
+  hasPostProcessors(): boolean;
+  clearPostProcessors(): PostProcessing;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): PostProcessing.AsObject;
-	static toObject(includeInstance: boolean, msg: PostProcessing): PostProcessing.AsObject;
-	static serializeBinaryToWriter(message: PostProcessing, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): PostProcessing;
-	static deserializeBinaryFromReader(message: PostProcessing, reader: jspb.BinaryReader): PostProcessing;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PostProcessing.AsObject;
+  static toObject(includeInstance: boolean, msg: PostProcessing): PostProcessing.AsObject;
+  static serializeBinaryToWriter(message: PostProcessing, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PostProcessing;
+  static deserializeBinaryFromReader(message: PostProcessing, reader: jspb.BinaryReader): PostProcessing;
 }
 
 export namespace PostProcessing {
-	export type AsObject = {
-		pipelineList: Array<string>;
-		postProcessors?: PostProcessors.AsObject;
-	};
+  export type AsObject = {
+    pipelineList: Array<string>,
+    postProcessors?: PostProcessors.AsObject,
+  }
 }
 
 export class PostProcessors extends jspb.Message {
-	getSymSpell(): SymSpell | undefined;
-	setSymSpell(value?: SymSpell): PostProcessors;
-	hasSymSpell(): boolean;
-	clearSymSpell(): PostProcessors;
+  getSymSpell(): SymSpell | undefined;
+  setSymSpell(value?: SymSpell): PostProcessors;
+  hasSymSpell(): boolean;
+  clearSymSpell(): PostProcessors;
 
-	getNormalization(): S2TNormalization | undefined;
-	setNormalization(value?: S2TNormalization): PostProcessors;
-	hasNormalization(): boolean;
-	clearNormalization(): PostProcessors;
+  getNormalization(): S2tNormalization | undefined;
+  setNormalization(value?: S2tNormalization): PostProcessors;
+  hasNormalization(): boolean;
+  clearNormalization(): PostProcessors;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): PostProcessors.AsObject;
-	static toObject(includeInstance: boolean, msg: PostProcessors): PostProcessors.AsObject;
-	static serializeBinaryToWriter(message: PostProcessors, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): PostProcessors;
-	static deserializeBinaryFromReader(message: PostProcessors, reader: jspb.BinaryReader): PostProcessors;
+  getLlmPostProcessing(): S2tLlmPostProcessing | undefined;
+  setLlmPostProcessing(value?: S2tLlmPostProcessing): PostProcessors;
+  hasLlmPostProcessing(): boolean;
+  clearLlmPostProcessing(): PostProcessors;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PostProcessors.AsObject;
+  static toObject(includeInstance: boolean, msg: PostProcessors): PostProcessors.AsObject;
+  static serializeBinaryToWriter(message: PostProcessors, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PostProcessors;
+  static deserializeBinaryFromReader(message: PostProcessors, reader: jspb.BinaryReader): PostProcessors;
 }
 
 export namespace PostProcessors {
-	export type AsObject = {
-		symSpell?: SymSpell.AsObject;
-		normalization?: S2TNormalization.AsObject;
-	};
+  export type AsObject = {
+    symSpell?: SymSpell.AsObject,
+    normalization?: S2tNormalization.AsObject,
+    llmPostProcessing?: S2tLlmPostProcessing.AsObject,
+  }
 }
 
 export class SymSpell extends jspb.Message {
-	getDictPath(): string;
-	setDictPath(value: string): SymSpell;
+  getDictPath(): string;
+  setDictPath(value: string): SymSpell;
 
-	getMaxDictionaryEditDistance(): number;
-	setMaxDictionaryEditDistance(value: number): SymSpell;
+  getMaxDictionaryEditDistance(): number;
+  setMaxDictionaryEditDistance(value: number): SymSpell;
 
-	getPrefixLength(): number;
-	setPrefixLength(value: number): SymSpell;
+  getPrefixLength(): number;
+  setPrefixLength(value: number): SymSpell;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): SymSpell.AsObject;
-	static toObject(includeInstance: boolean, msg: SymSpell): SymSpell.AsObject;
-	static serializeBinaryToWriter(message: SymSpell, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): SymSpell;
-	static deserializeBinaryFromReader(message: SymSpell, reader: jspb.BinaryReader): SymSpell;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SymSpell.AsObject;
+  static toObject(includeInstance: boolean, msg: SymSpell): SymSpell.AsObject;
+  static serializeBinaryToWriter(message: SymSpell, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SymSpell;
+  static deserializeBinaryFromReader(message: SymSpell, reader: jspb.BinaryReader): SymSpell;
 }
 
 export namespace SymSpell {
-	export type AsObject = {
-		dictPath: string;
-		maxDictionaryEditDistance: number;
-		prefixLength: number;
-	};
-}
-
-export class S2TNormalization extends jspb.Message {
-	getLanguage(): string;
-	setLanguage(value: string): S2TNormalization;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): S2TNormalization.AsObject;
-	static toObject(includeInstance: boolean, msg: S2TNormalization): S2TNormalization.AsObject;
-	static serializeBinaryToWriter(message: S2TNormalization, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): S2TNormalization;
-	static deserializeBinaryFromReader(message: S2TNormalization, reader: jspb.BinaryReader): S2TNormalization;
-}
-
-export namespace S2TNormalization {
-	export type AsObject = {
-		language: string;
-	};
+  export type AsObject = {
+    dictPath: string,
+    maxDictionaryEditDistance: number,
+    prefixLength: number,
+  }
+}
+
+export class S2tNormalization extends jspb.Message {
+  getLanguage(): string;
+  setLanguage(value: string): S2tNormalization;
+
+  getPipelineList(): Array<string>;
+  setPipelineList(value: Array<string>): S2tNormalization;
+  clearPipelineList(): S2tNormalization;
+  addPipeline(value: string, index?: number): S2tNormalization;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tNormalization.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tNormalization): S2tNormalization.AsObject;
+  static serializeBinaryToWriter(message: S2tNormalization, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tNormalization;
+  static deserializeBinaryFromReader(message: S2tNormalization, reader: jspb.BinaryReader): S2tNormalization;
+}
+
+export namespace S2tNormalization {
+  export type AsObject = {
+    language: string,
+    pipelineList: Array<string>,
+  }
+}
+
+export class S2tLlmPostProcessing extends jspb.Message {
+  getLlmHost(): string;
+  setLlmHost(value: string): S2tLlmPostProcessing;
+  hasLlmHost(): boolean;
+  clearLlmHost(): S2tLlmPostProcessing;
+
+  getLlmPort(): number;
+  setLlmPort(value: number): S2tLlmPostProcessing;
+  hasLlmPort(): boolean;
+  clearLlmPort(): S2tLlmPostProcessing;
+
+  getLlmRequestTimeout(): number;
+  setLlmRequestTimeout(value: number): S2tLlmPostProcessing;
+  hasLlmRequestTimeout(): boolean;
+  clearLlmRequestTimeout(): S2tLlmPostProcessing;
+
+  getS2tLlmPostProcessingCasingOptions(): S2tLlmPostProcessingCasingOptions | undefined;
+  setS2tLlmPostProcessingCasingOptions(value?: S2tLlmPostProcessingCasingOptions): S2tLlmPostProcessing;
+  hasS2tLlmPostProcessingCasingOptions(): boolean;
+  clearS2tLlmPostProcessingCasingOptions(): S2tLlmPostProcessing;
+
+  getS2tLlmPostProcessingPunctuationOptions(): S2tLlmPostProcessingPunctuationOptions | undefined;
+  setS2tLlmPostProcessingPunctuationOptions(value?: S2tLlmPostProcessingPunctuationOptions): S2tLlmPostProcessing;
+  hasS2tLlmPostProcessingPunctuationOptions(): boolean;
+  clearS2tLlmPostProcessingPunctuationOptions(): S2tLlmPostProcessing;
+
+  getS2tLlmPostProcessingSpellingCorrectionOptions(): S2tLlmPostProcessingSpellCorrectionOptions | undefined;
+  setS2tLlmPostProcessingSpellingCorrectionOptions(value?: S2tLlmPostProcessingSpellCorrectionOptions): S2tLlmPostProcessing;
+  hasS2tLlmPostProcessingSpellingCorrectionOptions(): boolean;
+  clearS2tLlmPostProcessingSpellingCorrectionOptions(): S2tLlmPostProcessing;
+
+  getS2tLlmPostProcessingSemanticCorrectionOptions(): S2tLlmPostProcessingSemanticCorrectionOptions | undefined;
+  setS2tLlmPostProcessingSemanticCorrectionOptions(value?: S2tLlmPostProcessingSemanticCorrectionOptions): S2tLlmPostProcessing;
+  hasS2tLlmPostProcessingSemanticCorrectionOptions(): boolean;
+  clearS2tLlmPostProcessingSemanticCorrectionOptions(): S2tLlmPostProcessing;
+
+  getS2tLlmPostProcessingTranslationOptions(): S2tLlmPostProcessingTranslationOptions | undefined;
+  setS2tLlmPostProcessingTranslationOptions(value?: S2tLlmPostProcessingTranslationOptions): S2tLlmPostProcessing;
+  hasS2tLlmPostProcessingTranslationOptions(): boolean;
+  clearS2tLlmPostProcessingTranslationOptions(): S2tLlmPostProcessing;
+
+  getS2tLlmPostProcessingInverseNormalizationOptions(): S2tLlmPostProcessingInverseNormalizationOptions | undefined;
+  setS2tLlmPostProcessingInverseNormalizationOptions(value?: S2tLlmPostProcessingInverseNormalizationOptions): S2tLlmPostProcessing;
+  hasS2tLlmPostProcessingInverseNormalizationOptions(): boolean;
+  clearS2tLlmPostProcessingInverseNormalizationOptions(): S2tLlmPostProcessing;
+
+  getS2tLlmPostProcessingNormalizationOptions(): S2tLlmPostProcessingNormalizationOptions | undefined;
+  setS2tLlmPostProcessingNormalizationOptions(value?: S2tLlmPostProcessingNormalizationOptions): S2tLlmPostProcessing;
+  hasS2tLlmPostProcessingNormalizationOptions(): boolean;
+  clearS2tLlmPostProcessingNormalizationOptions(): S2tLlmPostProcessing;
+
+  getS2tLlmPostProcessingSummarizationOptions(): S2tLlmPostProcessingSummarizationOptions | undefined;
+  setS2tLlmPostProcessingSummarizationOptions(value?: S2tLlmPostProcessingSummarizationOptions): S2tLlmPostProcessing;
+  hasS2tLlmPostProcessingSummarizationOptions(): boolean;
+  clearS2tLlmPostProcessingSummarizationOptions(): S2tLlmPostProcessing;
+
+  getS2tLlmPostProcessingUserPromptOptions(): S2tLlmPostProcessingUserPromptOptions | undefined;
+  setS2tLlmPostProcessingUserPromptOptions(value?: S2tLlmPostProcessingUserPromptOptions): S2tLlmPostProcessing;
+  hasS2tLlmPostProcessingUserPromptOptions(): boolean;
+  clearS2tLlmPostProcessingUserPromptOptions(): S2tLlmPostProcessing;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tLlmPostProcessing.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tLlmPostProcessing): S2tLlmPostProcessing.AsObject;
+  static serializeBinaryToWriter(message: S2tLlmPostProcessing, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tLlmPostProcessing;
+  static deserializeBinaryFromReader(message: S2tLlmPostProcessing, reader: jspb.BinaryReader): S2tLlmPostProcessing;
+}
+
+export namespace S2tLlmPostProcessing {
+  export type AsObject = {
+    llmHost?: string,
+    llmPort?: number,
+    llmRequestTimeout?: number,
+    s2tLlmPostProcessingCasingOptions?: S2tLlmPostProcessingCasingOptions.AsObject,
+    s2tLlmPostProcessingPunctuationOptions?: S2tLlmPostProcessingPunctuationOptions.AsObject,
+    s2tLlmPostProcessingSpellingCorrectionOptions?: S2tLlmPostProcessingSpellCorrectionOptions.AsObject,
+    s2tLlmPostProcessingSemanticCorrectionOptions?: S2tLlmPostProcessingSemanticCorrectionOptions.AsObject,
+    s2tLlmPostProcessingTranslationOptions?: S2tLlmPostProcessingTranslationOptions.AsObject,
+    s2tLlmPostProcessingInverseNormalizationOptions?: S2tLlmPostProcessingInverseNormalizationOptions.AsObject,
+    s2tLlmPostProcessingNormalizationOptions?: S2tLlmPostProcessingNormalizationOptions.AsObject,
+    s2tLlmPostProcessingSummarizationOptions?: S2tLlmPostProcessingSummarizationOptions.AsObject,
+    s2tLlmPostProcessingUserPromptOptions?: S2tLlmPostProcessingUserPromptOptions.AsObject,
+  }
+
+  export enum LlmHostCase { 
+    _LLM_HOST_NOT_SET = 0,
+    LLM_HOST = 1,
+  }
+
+  export enum LlmPortCase { 
+    _LLM_PORT_NOT_SET = 0,
+    LLM_PORT = 2,
+  }
+
+  export enum LlmRequestTimeoutCase { 
+    _LLM_REQUEST_TIMEOUT_NOT_SET = 0,
+    LLM_REQUEST_TIMEOUT = 3,
+  }
+
+  export enum S2tLlmPostProcessingCasingOptionsCase { 
+    _S2T_LLM_POST_PROCESSING_CASING_OPTIONS_NOT_SET = 0,
+    S2T_LLM_POST_PROCESSING_CASING_OPTIONS = 4,
+  }
+
+  export enum S2tLlmPostProcessingPunctuationOptionsCase { 
+    _S2T_LLM_POST_PROCESSING_PUNCTUATION_OPTIONS_NOT_SET = 0,
+    S2T_LLM_POST_PROCESSING_PUNCTUATION_OPTIONS = 5,
+  }
+
+  export enum S2tLlmPostProcessingSpellingCorrectionOptionsCase { 
+    _S2T_LLM_POST_PROCESSING_SPELLING_CORRECTION_OPTIONS_NOT_SET = 0,
+    S2T_LLM_POST_PROCESSING_SPELLING_CORRECTION_OPTIONS = 6,
+  }
+
+  export enum S2tLlmPostProcessingSemanticCorrectionOptionsCase { 
+    _S2T_LLM_POST_PROCESSING_SEMANTIC_CORRECTION_OPTIONS_NOT_SET = 0,
+    S2T_LLM_POST_PROCESSING_SEMANTIC_CORRECTION_OPTIONS = 7,
+  }
+
+  export enum S2tLlmPostProcessingTranslationOptionsCase { 
+    _S2T_LLM_POST_PROCESSING_TRANSLATION_OPTIONS_NOT_SET = 0,
+    S2T_LLM_POST_PROCESSING_TRANSLATION_OPTIONS = 8,
+  }
+
+  export enum S2tLlmPostProcessingInverseNormalizationOptionsCase { 
+    _S2T_LLM_POST_PROCESSING_INVERSE_NORMALIZATION_OPTIONS_NOT_SET = 0,
+    S2T_LLM_POST_PROCESSING_INVERSE_NORMALIZATION_OPTIONS = 9,
+  }
+
+  export enum S2tLlmPostProcessingNormalizationOptionsCase { 
+    _S2T_LLM_POST_PROCESSING_NORMALIZATION_OPTIONS_NOT_SET = 0,
+    S2T_LLM_POST_PROCESSING_NORMALIZATION_OPTIONS = 10,
+  }
+
+  export enum S2tLlmPostProcessingSummarizationOptionsCase { 
+    _S2T_LLM_POST_PROCESSING_SUMMARIZATION_OPTIONS_NOT_SET = 0,
+    S2T_LLM_POST_PROCESSING_SUMMARIZATION_OPTIONS = 11,
+  }
+
+  export enum S2tLlmPostProcessingUserPromptOptionsCase { 
+    _S2T_LLM_POST_PROCESSING_USER_PROMPT_OPTIONS_NOT_SET = 0,
+    S2T_LLM_POST_PROCESSING_USER_PROMPT_OPTIONS = 12,
+  }
+}
+
+export class S2tLlmPostProcessingCasingOptions extends jspb.Message {
+  getActive(): boolean;
+  setActive(value: boolean): S2tLlmPostProcessingCasingOptions;
+  hasActive(): boolean;
+  clearActive(): S2tLlmPostProcessingCasingOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tLlmPostProcessingCasingOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tLlmPostProcessingCasingOptions): S2tLlmPostProcessingCasingOptions.AsObject;
+  static serializeBinaryToWriter(message: S2tLlmPostProcessingCasingOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tLlmPostProcessingCasingOptions;
+  static deserializeBinaryFromReader(message: S2tLlmPostProcessingCasingOptions, reader: jspb.BinaryReader): S2tLlmPostProcessingCasingOptions;
+}
+
+export namespace S2tLlmPostProcessingCasingOptions {
+  export type AsObject = {
+    active?: boolean,
+  }
+
+  export enum ActiveCase { 
+    _ACTIVE_NOT_SET = 0,
+    ACTIVE = 1,
+  }
+}
+
+export class S2tLlmPostProcessingPunctuationOptions extends jspb.Message {
+  getActive(): boolean;
+  setActive(value: boolean): S2tLlmPostProcessingPunctuationOptions;
+  hasActive(): boolean;
+  clearActive(): S2tLlmPostProcessingPunctuationOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tLlmPostProcessingPunctuationOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tLlmPostProcessingPunctuationOptions): S2tLlmPostProcessingPunctuationOptions.AsObject;
+  static serializeBinaryToWriter(message: S2tLlmPostProcessingPunctuationOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tLlmPostProcessingPunctuationOptions;
+  static deserializeBinaryFromReader(message: S2tLlmPostProcessingPunctuationOptions, reader: jspb.BinaryReader): S2tLlmPostProcessingPunctuationOptions;
+}
+
+export namespace S2tLlmPostProcessingPunctuationOptions {
+  export type AsObject = {
+    active?: boolean,
+  }
+
+  export enum ActiveCase { 
+    _ACTIVE_NOT_SET = 0,
+    ACTIVE = 1,
+  }
+}
+
+export class S2tLlmPostProcessingSpellCorrectionOptions extends jspb.Message {
+  getActive(): boolean;
+  setActive(value: boolean): S2tLlmPostProcessingSpellCorrectionOptions;
+  hasActive(): boolean;
+  clearActive(): S2tLlmPostProcessingSpellCorrectionOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tLlmPostProcessingSpellCorrectionOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tLlmPostProcessingSpellCorrectionOptions): S2tLlmPostProcessingSpellCorrectionOptions.AsObject;
+  static serializeBinaryToWriter(message: S2tLlmPostProcessingSpellCorrectionOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tLlmPostProcessingSpellCorrectionOptions;
+  static deserializeBinaryFromReader(message: S2tLlmPostProcessingSpellCorrectionOptions, reader: jspb.BinaryReader): S2tLlmPostProcessingSpellCorrectionOptions;
+}
+
+export namespace S2tLlmPostProcessingSpellCorrectionOptions {
+  export type AsObject = {
+    active?: boolean,
+  }
+
+  export enum ActiveCase { 
+    _ACTIVE_NOT_SET = 0,
+    ACTIVE = 1,
+  }
+}
+
+export class S2tLlmPostProcessingSemanticCorrectionOptions extends jspb.Message {
+  getActive(): boolean;
+  setActive(value: boolean): S2tLlmPostProcessingSemanticCorrectionOptions;
+  hasActive(): boolean;
+  clearActive(): S2tLlmPostProcessingSemanticCorrectionOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tLlmPostProcessingSemanticCorrectionOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tLlmPostProcessingSemanticCorrectionOptions): S2tLlmPostProcessingSemanticCorrectionOptions.AsObject;
+  static serializeBinaryToWriter(message: S2tLlmPostProcessingSemanticCorrectionOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tLlmPostProcessingSemanticCorrectionOptions;
+  static deserializeBinaryFromReader(message: S2tLlmPostProcessingSemanticCorrectionOptions, reader: jspb.BinaryReader): S2tLlmPostProcessingSemanticCorrectionOptions;
+}
+
+export namespace S2tLlmPostProcessingSemanticCorrectionOptions {
+  export type AsObject = {
+    active?: boolean,
+  }
+
+  export enum ActiveCase { 
+    _ACTIVE_NOT_SET = 0,
+    ACTIVE = 1,
+  }
+}
+
+export class S2tLlmPostProcessingTranslationOptions extends jspb.Message {
+  getActive(): boolean;
+  setActive(value: boolean): S2tLlmPostProcessingTranslationOptions;
+  hasActive(): boolean;
+  clearActive(): S2tLlmPostProcessingTranslationOptions;
+
+  getLanguage(): string;
+  setLanguage(value: string): S2tLlmPostProcessingTranslationOptions;
+  hasLanguage(): boolean;
+  clearLanguage(): S2tLlmPostProcessingTranslationOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tLlmPostProcessingTranslationOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tLlmPostProcessingTranslationOptions): S2tLlmPostProcessingTranslationOptions.AsObject;
+  static serializeBinaryToWriter(message: S2tLlmPostProcessingTranslationOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tLlmPostProcessingTranslationOptions;
+  static deserializeBinaryFromReader(message: S2tLlmPostProcessingTranslationOptions, reader: jspb.BinaryReader): S2tLlmPostProcessingTranslationOptions;
+}
+
+export namespace S2tLlmPostProcessingTranslationOptions {
+  export type AsObject = {
+    active?: boolean,
+    language?: string,
+  }
+
+  export enum ActiveCase { 
+    _ACTIVE_NOT_SET = 0,
+    ACTIVE = 1,
+  }
+
+  export enum LanguageCase { 
+    _LANGUAGE_NOT_SET = 0,
+    LANGUAGE = 2,
+  }
+}
+
+export class S2tLlmPostProcessingInverseNormalizationOptions extends jspb.Message {
+  getActive(): boolean;
+  setActive(value: boolean): S2tLlmPostProcessingInverseNormalizationOptions;
+  hasActive(): boolean;
+  clearActive(): S2tLlmPostProcessingInverseNormalizationOptions;
+
+  getEmail(): boolean;
+  setEmail(value: boolean): S2tLlmPostProcessingInverseNormalizationOptions;
+  hasEmail(): boolean;
+  clearEmail(): S2tLlmPostProcessingInverseNormalizationOptions;
+
+  getPhoneNumber(): boolean;
+  setPhoneNumber(value: boolean): S2tLlmPostProcessingInverseNormalizationOptions;
+  hasPhoneNumber(): boolean;
+  clearPhoneNumber(): S2tLlmPostProcessingInverseNormalizationOptions;
+
+  getDateAndTime(): boolean;
+  setDateAndTime(value: boolean): S2tLlmPostProcessingInverseNormalizationOptions;
+  hasDateAndTime(): boolean;
+  clearDateAndTime(): S2tLlmPostProcessingInverseNormalizationOptions;
+
+  getCreditCardNumber(): boolean;
+  setCreditCardNumber(value: boolean): S2tLlmPostProcessingInverseNormalizationOptions;
+  hasCreditCardNumber(): boolean;
+  clearCreditCardNumber(): S2tLlmPostProcessingInverseNormalizationOptions;
+
+  getSocialSecurityNumber(): boolean;
+  setSocialSecurityNumber(value: boolean): S2tLlmPostProcessingInverseNormalizationOptions;
+  hasSocialSecurityNumber(): boolean;
+  clearSocialSecurityNumber(): S2tLlmPostProcessingInverseNormalizationOptions;
+
+  getTimeZone(): boolean;
+  setTimeZone(value: boolean): S2tLlmPostProcessingInverseNormalizationOptions;
+  hasTimeZone(): boolean;
+  clearTimeZone(): S2tLlmPostProcessingInverseNormalizationOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tLlmPostProcessingInverseNormalizationOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tLlmPostProcessingInverseNormalizationOptions): S2tLlmPostProcessingInverseNormalizationOptions.AsObject;
+  static serializeBinaryToWriter(message: S2tLlmPostProcessingInverseNormalizationOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tLlmPostProcessingInverseNormalizationOptions;
+  static deserializeBinaryFromReader(message: S2tLlmPostProcessingInverseNormalizationOptions, reader: jspb.BinaryReader): S2tLlmPostProcessingInverseNormalizationOptions;
+}
+
+export namespace S2tLlmPostProcessingInverseNormalizationOptions {
+  export type AsObject = {
+    active?: boolean,
+    email?: boolean,
+    phoneNumber?: boolean,
+    dateAndTime?: boolean,
+    creditCardNumber?: boolean,
+    socialSecurityNumber?: boolean,
+    timeZone?: boolean,
+  }
+
+  export enum ActiveCase { 
+    _ACTIVE_NOT_SET = 0,
+    ACTIVE = 1,
+  }
+
+  export enum EmailCase { 
+    _EMAIL_NOT_SET = 0,
+    EMAIL = 2,
+  }
+
+  export enum PhoneNumberCase { 
+    _PHONE_NUMBER_NOT_SET = 0,
+    PHONE_NUMBER = 3,
+  }
+
+  export enum DateAndTimeCase { 
+    _DATE_AND_TIME_NOT_SET = 0,
+    DATE_AND_TIME = 4,
+  }
+
+  export enum CreditCardNumberCase { 
+    _CREDIT_CARD_NUMBER_NOT_SET = 0,
+    CREDIT_CARD_NUMBER = 5,
+  }
+
+  export enum SocialSecurityNumberCase { 
+    _SOCIAL_SECURITY_NUMBER_NOT_SET = 0,
+    SOCIAL_SECURITY_NUMBER = 6,
+  }
+
+  export enum TimeZoneCase { 
+    _TIME_ZONE_NOT_SET = 0,
+    TIME_ZONE = 7,
+  }
+}
+
+export class S2tLlmPostProcessingNormalizationOptions extends jspb.Message {
+  getActive(): boolean;
+  setActive(value: boolean): S2tLlmPostProcessingNormalizationOptions;
+  hasActive(): boolean;
+  clearActive(): S2tLlmPostProcessingNormalizationOptions;
+
+  getEmail(): boolean;
+  setEmail(value: boolean): S2tLlmPostProcessingNormalizationOptions;
+  hasEmail(): boolean;
+  clearEmail(): S2tLlmPostProcessingNormalizationOptions;
+
+  getPhoneNumber(): boolean;
+  setPhoneNumber(value: boolean): S2tLlmPostProcessingNormalizationOptions;
+  hasPhoneNumber(): boolean;
+  clearPhoneNumber(): S2tLlmPostProcessingNormalizationOptions;
+
+  getDateAndTime(): boolean;
+  setDateAndTime(value: boolean): S2tLlmPostProcessingNormalizationOptions;
+  hasDateAndTime(): boolean;
+  clearDateAndTime(): S2tLlmPostProcessingNormalizationOptions;
+
+  getCreditCardNumber(): boolean;
+  setCreditCardNumber(value: boolean): S2tLlmPostProcessingNormalizationOptions;
+  hasCreditCardNumber(): boolean;
+  clearCreditCardNumber(): S2tLlmPostProcessingNormalizationOptions;
+
+  getSocialSecurityNumber(): boolean;
+  setSocialSecurityNumber(value: boolean): S2tLlmPostProcessingNormalizationOptions;
+  hasSocialSecurityNumber(): boolean;
+  clearSocialSecurityNumber(): S2tLlmPostProcessingNormalizationOptions;
+
+  getTimeZone(): boolean;
+  setTimeZone(value: boolean): S2tLlmPostProcessingNormalizationOptions;
+  hasTimeZone(): boolean;
+  clearTimeZone(): S2tLlmPostProcessingNormalizationOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tLlmPostProcessingNormalizationOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tLlmPostProcessingNormalizationOptions): S2tLlmPostProcessingNormalizationOptions.AsObject;
+  static serializeBinaryToWriter(message: S2tLlmPostProcessingNormalizationOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tLlmPostProcessingNormalizationOptions;
+  static deserializeBinaryFromReader(message: S2tLlmPostProcessingNormalizationOptions, reader: jspb.BinaryReader): S2tLlmPostProcessingNormalizationOptions;
+}
+
+export namespace S2tLlmPostProcessingNormalizationOptions {
+  export type AsObject = {
+    active?: boolean,
+    email?: boolean,
+    phoneNumber?: boolean,
+    dateAndTime?: boolean,
+    creditCardNumber?: boolean,
+    socialSecurityNumber?: boolean,
+    timeZone?: boolean,
+  }
+
+  export enum ActiveCase { 
+    _ACTIVE_NOT_SET = 0,
+    ACTIVE = 1,
+  }
+
+  export enum EmailCase { 
+    _EMAIL_NOT_SET = 0,
+    EMAIL = 2,
+  }
+
+  export enum PhoneNumberCase { 
+    _PHONE_NUMBER_NOT_SET = 0,
+    PHONE_NUMBER = 3,
+  }
+
+  export enum DateAndTimeCase { 
+    _DATE_AND_TIME_NOT_SET = 0,
+    DATE_AND_TIME = 4,
+  }
+
+  export enum CreditCardNumberCase { 
+    _CREDIT_CARD_NUMBER_NOT_SET = 0,
+    CREDIT_CARD_NUMBER = 5,
+  }
+
+  export enum SocialSecurityNumberCase { 
+    _SOCIAL_SECURITY_NUMBER_NOT_SET = 0,
+    SOCIAL_SECURITY_NUMBER = 6,
+  }
+
+  export enum TimeZoneCase { 
+    _TIME_ZONE_NOT_SET = 0,
+    TIME_ZONE = 7,
+  }
+}
+
+export class S2tLlmPostProcessingSummarizationOptions extends jspb.Message {
+  getActive(): boolean;
+  setActive(value: boolean): S2tLlmPostProcessingSummarizationOptions;
+  hasActive(): boolean;
+  clearActive(): S2tLlmPostProcessingSummarizationOptions;
+
+  getMinChars(): number;
+  setMinChars(value: number): S2tLlmPostProcessingSummarizationOptions;
+  hasMinChars(): boolean;
+  clearMinChars(): S2tLlmPostProcessingSummarizationOptions;
+
+  getMaxChars(): number;
+  setMaxChars(value: number): S2tLlmPostProcessingSummarizationOptions;
+  hasMaxChars(): boolean;
+  clearMaxChars(): S2tLlmPostProcessingSummarizationOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tLlmPostProcessingSummarizationOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tLlmPostProcessingSummarizationOptions): S2tLlmPostProcessingSummarizationOptions.AsObject;
+  static serializeBinaryToWriter(message: S2tLlmPostProcessingSummarizationOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tLlmPostProcessingSummarizationOptions;
+  static deserializeBinaryFromReader(message: S2tLlmPostProcessingSummarizationOptions, reader: jspb.BinaryReader): S2tLlmPostProcessingSummarizationOptions;
+}
+
+export namespace S2tLlmPostProcessingSummarizationOptions {
+  export type AsObject = {
+    active?: boolean,
+    minChars?: number,
+    maxChars?: number,
+  }
+
+  export enum ActiveCase { 
+    _ACTIVE_NOT_SET = 0,
+    ACTIVE = 1,
+  }
+
+  export enum MinCharsCase { 
+    _MIN_CHARS_NOT_SET = 0,
+    MIN_CHARS = 2,
+  }
+
+  export enum MaxCharsCase { 
+    _MAX_CHARS_NOT_SET = 0,
+    MAX_CHARS = 3,
+  }
+}
+
+export class S2tLlmPostProcessingUserPromptOptions extends jspb.Message {
+  getActive(): boolean;
+  setActive(value: boolean): S2tLlmPostProcessingUserPromptOptions;
+  hasActive(): boolean;
+  clearActive(): S2tLlmPostProcessingUserPromptOptions;
+
+  getPrompt(): string;
+  setPrompt(value: string): S2tLlmPostProcessingUserPromptOptions;
+  hasPrompt(): boolean;
+  clearPrompt(): S2tLlmPostProcessingUserPromptOptions;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): S2tLlmPostProcessingUserPromptOptions.AsObject;
+  static toObject(includeInstance: boolean, msg: S2tLlmPostProcessingUserPromptOptions): S2tLlmPostProcessingUserPromptOptions.AsObject;
+  static serializeBinaryToWriter(message: S2tLlmPostProcessingUserPromptOptions, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): S2tLlmPostProcessingUserPromptOptions;
+  static deserializeBinaryFromReader(message: S2tLlmPostProcessingUserPromptOptions, reader: jspb.BinaryReader): S2tLlmPostProcessingUserPromptOptions;
+}
+
+export namespace S2tLlmPostProcessingUserPromptOptions {
+  export type AsObject = {
+    active?: boolean,
+    prompt?: string,
+  }
+
+  export enum ActiveCase { 
+    _ACTIVE_NOT_SET = 0,
+    ACTIVE = 1,
+  }
+
+  export enum PromptCase { 
+    _PROMPT_NOT_SET = 0,
+    PROMPT = 2,
+  }
 }
 
 export class Logging extends jspb.Message {
-	getType(): string;
-	setType(value: string): Logging;
+  getType(): string;
+  setType(value: string): Logging;
 
-	getPath(): string;
-	setPath(value: string): Logging;
+  getPath(): string;
+  setPath(value: string): Logging;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): Logging.AsObject;
-	static toObject(includeInstance: boolean, msg: Logging): Logging.AsObject;
-	static serializeBinaryToWriter(message: Logging, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): Logging;
-	static deserializeBinaryFromReader(message: Logging, reader: jspb.BinaryReader): Logging;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Logging.AsObject;
+  static toObject(includeInstance: boolean, msg: Logging): Logging.AsObject;
+  static serializeBinaryToWriter(message: Logging, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Logging;
+  static deserializeBinaryFromReader(message: Logging, reader: jspb.BinaryReader): Logging;
 }
 
 export namespace Logging {
-	export type AsObject = {
-		type: string;
-		path: string;
-	};
+  export type AsObject = {
+    type: string,
+    path: string,
+  }
 }
 
 export class ListS2tLanguageModelsRequest extends jspb.Message {
-	getIdsList(): Array<string>;
-	setIdsList(value: Array<string>): ListS2tLanguageModelsRequest;
-	clearIdsList(): ListS2tLanguageModelsRequest;
-	addIds(value: string, index?: number): ListS2tLanguageModelsRequest;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): ListS2tLanguageModelsRequest.AsObject;
-	static toObject(includeInstance: boolean, msg: ListS2tLanguageModelsRequest): ListS2tLanguageModelsRequest.AsObject;
-	static serializeBinaryToWriter(message: ListS2tLanguageModelsRequest, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): ListS2tLanguageModelsRequest;
-	static deserializeBinaryFromReader(
-		message: ListS2tLanguageModelsRequest,
-		reader: jspb.BinaryReader
-	): ListS2tLanguageModelsRequest;
+  getIdsList(): Array<string>;
+  setIdsList(value: Array<string>): ListS2tLanguageModelsRequest;
+  clearIdsList(): ListS2tLanguageModelsRequest;
+  addIds(value: string, index?: number): ListS2tLanguageModelsRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListS2tLanguageModelsRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ListS2tLanguageModelsRequest): ListS2tLanguageModelsRequest.AsObject;
+  static serializeBinaryToWriter(message: ListS2tLanguageModelsRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListS2tLanguageModelsRequest;
+  static deserializeBinaryFromReader(message: ListS2tLanguageModelsRequest, reader: jspb.BinaryReader): ListS2tLanguageModelsRequest;
 }
 
 export namespace ListS2tLanguageModelsRequest {
-	export type AsObject = {
-		idsList: Array<string>;
-	};
+  export type AsObject = {
+    idsList: Array<string>,
+  }
 }
 
 export class LanguageModelPipelineId extends jspb.Message {
-	getPipelineId(): string;
-	setPipelineId(value: string): LanguageModelPipelineId;
+  getPipelineId(): string;
+  setPipelineId(value: string): LanguageModelPipelineId;
 
-	getModelNamesList(): Array<string>;
-	setModelNamesList(value: Array<string>): LanguageModelPipelineId;
-	clearModelNamesList(): LanguageModelPipelineId;
-	addModelNames(value: string, index?: number): LanguageModelPipelineId;
+  getModelNamesList(): Array<string>;
+  setModelNamesList(value: Array<string>): LanguageModelPipelineId;
+  clearModelNamesList(): LanguageModelPipelineId;
+  addModelNames(value: string, index?: number): LanguageModelPipelineId;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): LanguageModelPipelineId.AsObject;
-	static toObject(includeInstance: boolean, msg: LanguageModelPipelineId): LanguageModelPipelineId.AsObject;
-	static serializeBinaryToWriter(message: LanguageModelPipelineId, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): LanguageModelPipelineId;
-	static deserializeBinaryFromReader(
-		message: LanguageModelPipelineId,
-		reader: jspb.BinaryReader
-	): LanguageModelPipelineId;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LanguageModelPipelineId.AsObject;
+  static toObject(includeInstance: boolean, msg: LanguageModelPipelineId): LanguageModelPipelineId.AsObject;
+  static serializeBinaryToWriter(message: LanguageModelPipelineId, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LanguageModelPipelineId;
+  static deserializeBinaryFromReader(message: LanguageModelPipelineId, reader: jspb.BinaryReader): LanguageModelPipelineId;
 }
 
 export namespace LanguageModelPipelineId {
-	export type AsObject = {
-		pipelineId: string;
-		modelNamesList: Array<string>;
-	};
+  export type AsObject = {
+    pipelineId: string,
+    modelNamesList: Array<string>,
+  }
 }
 
 export class ListS2tLanguageModelsResponse extends jspb.Message {
-	getLmPipelineIdsList(): Array<LanguageModelPipelineId>;
-	setLmPipelineIdsList(value: Array<LanguageModelPipelineId>): ListS2tLanguageModelsResponse;
-	clearLmPipelineIdsList(): ListS2tLanguageModelsResponse;
-	addLmPipelineIds(value?: LanguageModelPipelineId, index?: number): LanguageModelPipelineId;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): ListS2tLanguageModelsResponse.AsObject;
-	static toObject(includeInstance: boolean, msg: ListS2tLanguageModelsResponse): ListS2tLanguageModelsResponse.AsObject;
-	static serializeBinaryToWriter(message: ListS2tLanguageModelsResponse, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): ListS2tLanguageModelsResponse;
-	static deserializeBinaryFromReader(
-		message: ListS2tLanguageModelsResponse,
-		reader: jspb.BinaryReader
-	): ListS2tLanguageModelsResponse;
+  getLmPipelineIdsList(): Array<LanguageModelPipelineId>;
+  setLmPipelineIdsList(value: Array<LanguageModelPipelineId>): ListS2tLanguageModelsResponse;
+  clearLmPipelineIdsList(): ListS2tLanguageModelsResponse;
+  addLmPipelineIds(value?: LanguageModelPipelineId, index?: number): LanguageModelPipelineId;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListS2tLanguageModelsResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ListS2tLanguageModelsResponse): ListS2tLanguageModelsResponse.AsObject;
+  static serializeBinaryToWriter(message: ListS2tLanguageModelsResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListS2tLanguageModelsResponse;
+  static deserializeBinaryFromReader(message: ListS2tLanguageModelsResponse, reader: jspb.BinaryReader): ListS2tLanguageModelsResponse;
 }
 
 export namespace ListS2tLanguageModelsResponse {
-	export type AsObject = {
-		lmPipelineIdsList: Array<LanguageModelPipelineId.AsObject>;
-	};
+  export type AsObject = {
+    lmPipelineIdsList: Array<LanguageModelPipelineId.AsObject>,
+  }
 }
 
 export class CreateUserLanguageModelRequest extends jspb.Message {
-	getLanguageModelName(): string;
-	setLanguageModelName(value: string): CreateUserLanguageModelRequest;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): CreateUserLanguageModelRequest.AsObject;
-	static toObject(
-		includeInstance: boolean,
-		msg: CreateUserLanguageModelRequest
-	): CreateUserLanguageModelRequest.AsObject;
-	static serializeBinaryToWriter(message: CreateUserLanguageModelRequest, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): CreateUserLanguageModelRequest;
-	static deserializeBinaryFromReader(
-		message: CreateUserLanguageModelRequest,
-		reader: jspb.BinaryReader
-	): CreateUserLanguageModelRequest;
+  getLanguageModelName(): string;
+  setLanguageModelName(value: string): CreateUserLanguageModelRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CreateUserLanguageModelRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: CreateUserLanguageModelRequest): CreateUserLanguageModelRequest.AsObject;
+  static serializeBinaryToWriter(message: CreateUserLanguageModelRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CreateUserLanguageModelRequest;
+  static deserializeBinaryFromReader(message: CreateUserLanguageModelRequest, reader: jspb.BinaryReader): CreateUserLanguageModelRequest;
 }
 
 export namespace CreateUserLanguageModelRequest {
-	export type AsObject = {
-		languageModelName: string;
-	};
+  export type AsObject = {
+    languageModelName: string,
+  }
 }
 
 export class DeleteUserLanguageModelRequest extends jspb.Message {
-	getLanguageModelName(): string;
-	setLanguageModelName(value: string): DeleteUserLanguageModelRequest;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): DeleteUserLanguageModelRequest.AsObject;
-	static toObject(
-		includeInstance: boolean,
-		msg: DeleteUserLanguageModelRequest
-	): DeleteUserLanguageModelRequest.AsObject;
-	static serializeBinaryToWriter(message: DeleteUserLanguageModelRequest, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): DeleteUserLanguageModelRequest;
-	static deserializeBinaryFromReader(
-		message: DeleteUserLanguageModelRequest,
-		reader: jspb.BinaryReader
-	): DeleteUserLanguageModelRequest;
+  getLanguageModelName(): string;
+  setLanguageModelName(value: string): DeleteUserLanguageModelRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DeleteUserLanguageModelRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: DeleteUserLanguageModelRequest): DeleteUserLanguageModelRequest.AsObject;
+  static serializeBinaryToWriter(message: DeleteUserLanguageModelRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DeleteUserLanguageModelRequest;
+  static deserializeBinaryFromReader(message: DeleteUserLanguageModelRequest, reader: jspb.BinaryReader): DeleteUserLanguageModelRequest;
 }
 
 export namespace DeleteUserLanguageModelRequest {
-	export type AsObject = {
-		languageModelName: string;
-	};
+  export type AsObject = {
+    languageModelName: string,
+  }
 }
 
 export class AddDataToUserLanguageModelRequest extends jspb.Message {
-	getLanguageModelName(): string;
-	setLanguageModelName(value: string): AddDataToUserLanguageModelRequest;
-
-	getZippedData(): Uint8Array | string;
-	getZippedData_asU8(): Uint8Array;
-	getZippedData_asB64(): string;
-	setZippedData(value: Uint8Array | string): AddDataToUserLanguageModelRequest;
-
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): AddDataToUserLanguageModelRequest.AsObject;
-	static toObject(
-		includeInstance: boolean,
-		msg: AddDataToUserLanguageModelRequest
-	): AddDataToUserLanguageModelRequest.AsObject;
-	static serializeBinaryToWriter(message: AddDataToUserLanguageModelRequest, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): AddDataToUserLanguageModelRequest;
-	static deserializeBinaryFromReader(
-		message: AddDataToUserLanguageModelRequest,
-		reader: jspb.BinaryReader
-	): AddDataToUserLanguageModelRequest;
+  getLanguageModelName(): string;
+  setLanguageModelName(value: string): AddDataToUserLanguageModelRequest;
+
+  getZippedData(): Uint8Array | string;
+  getZippedData_asU8(): Uint8Array;
+  getZippedData_asB64(): string;
+  setZippedData(value: Uint8Array | string): AddDataToUserLanguageModelRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AddDataToUserLanguageModelRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: AddDataToUserLanguageModelRequest): AddDataToUserLanguageModelRequest.AsObject;
+  static serializeBinaryToWriter(message: AddDataToUserLanguageModelRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AddDataToUserLanguageModelRequest;
+  static deserializeBinaryFromReader(message: AddDataToUserLanguageModelRequest, reader: jspb.BinaryReader): AddDataToUserLanguageModelRequest;
 }
 
 export namespace AddDataToUserLanguageModelRequest {
-	export type AsObject = {
-		languageModelName: string;
-		zippedData: Uint8Array | string;
-	};
+  export type AsObject = {
+    languageModelName: string,
+    zippedData: Uint8Array | string,
+  }
 }
 
 export class TrainUserLanguageModelRequest extends jspb.Message {
-	getLanguageModelName(): string;
-	setLanguageModelName(value: string): TrainUserLanguageModelRequest;
+  getLanguageModelName(): string;
+  setLanguageModelName(value: string): TrainUserLanguageModelRequest;
 
-	getOrder(): number;
-	setOrder(value: number): TrainUserLanguageModelRequest;
+  getOrder(): number;
+  setOrder(value: number): TrainUserLanguageModelRequest;
 
-	serializeBinary(): Uint8Array;
-	toObject(includeInstance?: boolean): TrainUserLanguageModelRequest.AsObject;
-	static toObject(includeInstance: boolean, msg: TrainUserLanguageModelRequest): TrainUserLanguageModelRequest.AsObject;
-	static serializeBinaryToWriter(message: TrainUserLanguageModelRequest, writer: jspb.BinaryWriter): void;
-	static deserializeBinary(bytes: Uint8Array): TrainUserLanguageModelRequest;
-	static deserializeBinaryFromReader(
-		message: TrainUserLanguageModelRequest,
-		reader: jspb.BinaryReader
-	): TrainUserLanguageModelRequest;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TrainUserLanguageModelRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: TrainUserLanguageModelRequest): TrainUserLanguageModelRequest.AsObject;
+  static serializeBinaryToWriter(message: TrainUserLanguageModelRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TrainUserLanguageModelRequest;
+  static deserializeBinaryFromReader(message: TrainUserLanguageModelRequest, reader: jspb.BinaryReader): TrainUserLanguageModelRequest;
 }
 
 export namespace TrainUserLanguageModelRequest {
-	export type AsObject = {
-		languageModelName: string;
-		order: number;
-	};
-}
-
-export enum Decoding {
-	DEFAULT = 0,
-	GREEDY = 1,
-	BEAM_SEARCH_WITH_LM = 2,
-	BEAM_SEARCH = 3
-}
-export enum InferenceBackend {
-	INFERENCE_BACKEND_UNKNOWN = 0,
-	INFERENCE_BACKEND_PYTORCH = 1,
-	INFERENCE_BACKEND_FLAX = 2
+  export type AsObject = {
+    languageModelName: string,
+    order: number,
+  }
+}
+
+export class ListS2tNormalizationPipelinesRequest extends jspb.Message {
+  getLanguage(): string;
+  setLanguage(value: string): ListS2tNormalizationPipelinesRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListS2tNormalizationPipelinesRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ListS2tNormalizationPipelinesRequest): ListS2tNormalizationPipelinesRequest.AsObject;
+  static serializeBinaryToWriter(message: ListS2tNormalizationPipelinesRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListS2tNormalizationPipelinesRequest;
+  static deserializeBinaryFromReader(message: ListS2tNormalizationPipelinesRequest, reader: jspb.BinaryReader): ListS2tNormalizationPipelinesRequest;
+}
+
+export namespace ListS2tNormalizationPipelinesRequest {
+  export type AsObject = {
+    language: string,
+  }
+}
+
+export class ListS2tNormalizationPipelinesResponse extends jspb.Message {
+  getS2tNormalizationPipelinesList(): Array<string>;
+  setS2tNormalizationPipelinesList(value: Array<string>): ListS2tNormalizationPipelinesResponse;
+  clearS2tNormalizationPipelinesList(): ListS2tNormalizationPipelinesResponse;
+  addS2tNormalizationPipelines(value: string, index?: number): ListS2tNormalizationPipelinesResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListS2tNormalizationPipelinesResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ListS2tNormalizationPipelinesResponse): ListS2tNormalizationPipelinesResponse.AsObject;
+  static serializeBinaryToWriter(message: ListS2tNormalizationPipelinesResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListS2tNormalizationPipelinesResponse;
+  static deserializeBinaryFromReader(message: ListS2tNormalizationPipelinesResponse, reader: jspb.BinaryReader): ListS2tNormalizationPipelinesResponse;
+}
+
+export namespace ListS2tNormalizationPipelinesResponse {
+  export type AsObject = {
+    s2tNormalizationPipelinesList: Array<string>,
+  }
+}
+
+export enum Decoding { 
+  DEFAULT = 0,
+  GREEDY = 1,
+  BEAM_SEARCH_WITH_LM = 2,
+  BEAM_SEARCH = 3,
+}
+export enum InferenceBackend { 
+  INFERENCE_BACKEND_UNKNOWN = 0,
+  INFERENCE_BACKEND_PYTORCH = 1,
+  INFERENCE_BACKEND_FLAX = 2,
+  INFERENCE_BACKEND_CLOUD_SERVICE_AMAZON = 3,
+  INFERENCE_BACKEND_CLOUD_SERVICE_DEEPGRAM = 4,
+  INFERENCE_BACKEND_CLOUD_SERVICE_GOOGLE = 5,
+  INFERENCE_BACKEND_CLOUD_SERVICE_MICROSOFT = 6,
 }