@ondewo/s2t-client-typescript 6.1.0 → 7.1.0

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

@@ -476,8 +476,15 @@ export class UtteranceDetectionOptions extends jspb.Message {
   getNextChunkTimeout(): number;
   setNextChunkTimeout(value: number): UtteranceDetectionOptions;
 
+  getTurnDetection(): TurnDetectionOptions | undefined;
+  setTurnDetection(value?: TurnDetectionOptions): UtteranceDetectionOptions;
+  hasTurnDetection(): boolean;
+  clearTurnDetection(): UtteranceDetectionOptions;
+
   getOneofTranscribeNotFinalCase(): UtteranceDetectionOptions.OneofTranscribeNotFinalCase;
 
+  getOneofTurnDetectionCase(): UtteranceDetectionOptions.OneofTurnDetectionCase;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): UtteranceDetectionOptions.AsObject;
   static toObject(includeInstance: boolean, msg: UtteranceDetectionOptions): UtteranceDetectionOptions.AsObject;
@@ -490,12 +497,18 @@ export namespace UtteranceDetectionOptions {
   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 OneofTurnDetectionCase { 
+    ONEOF_TURN_DETECTION_NOT_SET = 0,
+    TURN_DETECTION = 3,
+  }
 }
 
 export class PostProcessingOptions extends jspb.Message {
@@ -510,6 +523,9 @@ export class PostProcessingOptions extends jspb.Message {
   hasConfig(): boolean;
   clearConfig(): PostProcessingOptions;
 
+  getLlmPostProcessing(): boolean;
+  setLlmPostProcessing(value: boolean): PostProcessingOptions;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): PostProcessingOptions.AsObject;
   static toObject(includeInstance: boolean, msg: PostProcessingOptions): PostProcessingOptions.AsObject;
@@ -523,6 +539,7 @@ export namespace PostProcessingOptions {
     spellingCorrection: boolean,
     normalize: boolean,
     config?: PostProcessing.AsObject,
+    llmPostProcessing: boolean,
   }
 }
 
@@ -959,19 +976,19 @@ export namespace ListS2tDomainsResponse {
   }
 }
 
-export class S2TGetServiceInfoResponse extends jspb.Message {
+export class S2tGetServiceInfoResponse extends jspb.Message {
   getVersion(): string;
-  setVersion(value: string): S2TGetServiceInfoResponse;
+  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;
+  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 namespace S2tGetServiceInfoResponse {
   export type AsObject = {
     version: string,
   }
@@ -981,16 +998,16 @@ export class Speech2TextConfig extends jspb.Message {
   getId(): string;
   setId(value: string): Speech2TextConfig;
 
-  getDescription(): S2TDescription | undefined;
-  setDescription(value?: S2TDescription): 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;
+  getInference(): S2tInference | undefined;
+  setInference(value?: S2tInference): Speech2TextConfig;
   hasInference(): boolean;
   clearInference(): Speech2TextConfig;
 
@@ -1025,9 +1042,9 @@ export class Speech2TextConfig extends jspb.Message {
 export namespace Speech2TextConfig {
   export type AsObject = {
     id: string,
-    description?: S2TDescription.AsObject,
+    description?: S2tDescription.AsObject,
     active: boolean,
-    inference?: S2TInference.AsObject,
+    inference?: S2tInference.AsObject,
     streamingServer?: StreamingServer.AsObject,
     voiceActivityDetection?: VoiceActivityDetection.AsObject,
     postProcessing?: PostProcessing.AsObject,
@@ -1035,28 +1052,28 @@ export namespace Speech2TextConfig {
   }
 }
 
-export class S2TDescription extends jspb.Message {
+export class S2tDescription extends jspb.Message {
   getLanguage(): string;
-  setLanguage(value: string): S2TDescription;
+  setLanguage(value: string): S2tDescription;
 
   getPipelineOwner(): string;
-  setPipelineOwner(value: string): S2TDescription;
+  setPipelineOwner(value: string): S2tDescription;
 
   getDomain(): string;
-  setDomain(value: string): S2TDescription;
+  setDomain(value: string): S2tDescription;
 
   getComments(): string;
-  setComments(value: string): S2TDescription;
+  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;
+  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 namespace S2tDescription {
   export type AsObject = {
     language: string,
     pipelineOwner: string,
@@ -1065,29 +1082,29 @@ export namespace S2TDescription {
   }
 }
 
-export class S2TInference extends jspb.Message {
+export class S2tInference extends jspb.Message {
   getAcousticModels(): AcousticModels | undefined;
-  setAcousticModels(value?: AcousticModels): S2TInference;
+  setAcousticModels(value?: AcousticModels): S2tInference;
   hasAcousticModels(): boolean;
-  clearAcousticModels(): S2TInference;
+  clearAcousticModels(): S2tInference;
 
   getLanguageModels(): LanguageModels | undefined;
-  setLanguageModels(value?: LanguageModels): S2TInference;
+  setLanguageModels(value?: LanguageModels): S2tInference;
   hasLanguageModels(): boolean;
-  clearLanguageModels(): S2TInference;
+  clearLanguageModels(): S2tInference;
 
   getInferenceBackend(): InferenceBackend;
-  setInferenceBackend(value: InferenceBackend): S2TInference;
+  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;
+  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 namespace S2tInference {
   export type AsObject = {
     acousticModels?: AcousticModels.AsObject,
     languageModels?: LanguageModels.AsObject,
@@ -1567,6 +1584,11 @@ export class StreamingSpeechRecognition extends jspb.Message {
   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;
@@ -1582,6 +1604,98 @@ export namespace StreamingSpeechRecognition {
     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;
+
+  getLlmModelName(): string;
+  setLlmModelName(value: string): TurnDetectionOptions;
+  hasLlmModelName(): boolean;
+  clearLlmModelName(): TurnDetectionOptions;
+
+  getLlmHeaders(): google_protobuf_struct_pb.Struct | undefined;
+  setLlmHeaders(value?: google_protobuf_struct_pb.Struct): TurnDetectionOptions;
+  hasLlmHeaders(): boolean;
+  clearLlmHeaders(): 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,
+    llmModelName?: string,
+    llmHeaders?: google_protobuf_struct_pb.Struct.AsObject,
+  }
+
+  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 enum LlmModelNameCase { 
+    _LLM_MODEL_NAME_NOT_SET = 0,
+    LLM_MODEL_NAME = 6,
+  }
+
+  export enum LlmHeadersCase { 
+    _LLM_HEADERS_NOT_SET = 0,
+    LLM_HEADERS = 7,
   }
 }
 
@@ -1683,11 +1797,16 @@ export class PostProcessors extends jspb.Message {
   hasSymSpell(): boolean;
   clearSymSpell(): PostProcessors;
 
-  getNormalization(): S2TNormalization | undefined;
-  setNormalization(value?: S2TNormalization): PostProcessors;
+  getNormalization(): S2tNormalization | undefined;
+  setNormalization(value?: S2tNormalization): PostProcessors;
   hasNormalization(): boolean;
   clearNormalization(): 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;
@@ -1699,7 +1818,8 @@ export class PostProcessors extends jspb.Message {
 export namespace PostProcessors {
   export type AsObject = {
     symSpell?: SymSpell.AsObject,
-    normalization?: S2TNormalization.AsObject,
+    normalization?: S2tNormalization.AsObject,
+    llmPostProcessing?: S2tLlmPostProcessing.AsObject,
   }
 }
 
@@ -1729,30 +1849,599 @@ export namespace SymSpell {
   }
 }
 
-export class S2TNormalization extends jspb.Message {
+export class S2tNormalization extends jspb.Message {
   getLanguage(): string;
-  setLanguage(value: string): S2TNormalization;
+  setLanguage(value: string): S2tNormalization;
 
   getPipelineList(): Array<string>;
-  setPipelineList(value: Array<string>): S2TNormalization;
-  clearPipelineList(): S2TNormalization;
-  addPipeline(value: string, index?: number): S2TNormalization;
+  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;
+  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 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;
+
+  getLlmModelName(): string;
+  setLlmModelName(value: string): S2tLlmPostProcessing;
+  hasLlmModelName(): boolean;
+  clearLlmModelName(): S2tLlmPostProcessing;
+
+  getLlmHeaders(): google_protobuf_struct_pb.Struct | undefined;
+  setLlmHeaders(value?: google_protobuf_struct_pb.Struct): S2tLlmPostProcessing;
+  hasLlmHeaders(): boolean;
+  clearLlmHeaders(): 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,
+    llmModelName?: string,
+    llmHeaders?: google_protobuf_struct_pb.Struct.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 enum LlmModelNameCase { 
+    _LLM_MODEL_NAME_NOT_SET = 0,
+    LLM_MODEL_NAME = 13,
+  }
+
+  export enum LlmHeadersCase { 
+    _LLM_HEADERS_NOT_SET = 0,
+    LLM_HEADERS = 14,
+  }
+}
+
+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;
@@ -1921,6 +2610,44 @@ export namespace TrainUserLanguageModelRequest {
   }
 }
 
+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,