@ondewo/csi-client-angular/api/ondewo/nlu/aiservices.pb.d.ts

ONDEWO Conversation System Integration (CSI) Client library for Angular

import { GrpcMessage, RecursivePartial, ToProtobufJSONOptions } from '@ngx-grpc/common';
import { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';
import * as googleProtobuf003 from '@ngx-grpc/well-known-types';
import * as ondewoNlu012 from '../../ondewo/nlu/intent.pb';
import * as ondewoNlu013 from '../../ondewo/nlu/entity-type.pb';
import * as ondewoNlu014 from '../../ondewo/nlu/ccai-project.pb';
import * as ondewoNlu015 from '../../ondewo/nlu/session.pb';
export declare enum Mode {
    UNSPECIFIED = 0,
    EXCLUSIVE = 1,
    INCLUSIVE = 2
}
export declare enum IntentAlgorithms {
    OndewoIntentExactContextDetector = 0,
    OndewoIntentExactMatch = 1,
    OndewoIntentNamedExactMatch = 2,
    OndewoIntentSimilarityMatch = 3,
    OndewoIntentNamedSimilarityMatch = 4,
    OndewoIntentBertClassifier = 7,
    OndewoIntentMetaClassifier = 8,
    IntentExitDetector = 10,
    OndewoIntentRankingMatch = 11,
    OndewoWeightedEnsemble = 13,
    OndewoIntentExitDetector = 14,
    OndewoIntentParameterMatch = 15
}
/**
 * Message implementation for ondewo.nlu.ListLlmModelsRequest
 */
export declare class ListLlmModelsRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ListLlmModelsRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ListLlmModelsRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ListLlmModelsRequest, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: ListLlmModelsRequest, _writer: BinaryWriter): void;
    private _ccaiServiceName;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ListLlmModelsRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<ListLlmModelsRequest.AsObject>);
    get ccaiServiceName(): string;
    set ccaiServiceName(value: string);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): ListLlmModelsRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ListLlmModelsRequest.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): ListLlmModelsRequest.AsProtobufJSON;
}
export declare namespace ListLlmModelsRequest {
    /**
     * Standard JavaScript object representation for ListLlmModelsRequest
     */
    interface AsObject {
        ccaiServiceName: string;
    }
    /**
     * Protobuf JSON representation for ListLlmModelsRequest
     */
    interface AsProtobufJSON {
        ccaiServiceName: string;
    }
}
/**
 * Message implementation for ondewo.nlu.ListLlmModelsResponse
 */
export declare class ListLlmModelsResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ListLlmModelsResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ListLlmModelsResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ListLlmModelsResponse, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: ListLlmModelsResponse, _writer: BinaryWriter): void;
    private _llmModels?;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ListLlmModelsResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<ListLlmModelsResponse.AsObject>);
    get llmModels(): LlmModel[] | undefined;
    set llmModels(value: LlmModel[] | undefined);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): ListLlmModelsResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ListLlmModelsResponse.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): ListLlmModelsResponse.AsProtobufJSON;
}
export declare namespace ListLlmModelsResponse {
    /**
     * Standard JavaScript object representation for ListLlmModelsResponse
     */
    interface AsObject {
        llmModels?: LlmModel.AsObject[];
    }
    /**
     * Protobuf JSON representation for ListLlmModelsResponse
     */
    interface AsProtobufJSON {
        llmModels: LlmModel.AsProtobufJSON[] | null;
    }
}
/**
 * Message implementation for ondewo.nlu.LlmModel
 */
export declare class LlmModel implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): LlmModel;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: LlmModel): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: LlmModel, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: LlmModel, _writer: BinaryWriter): void;
    private _name;
    private _displayName;
    private _description;
    private _ccaiServiceName;
    private _ccaiServiceProvider;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of LlmModel to deeply clone from
     */
    constructor(_value?: RecursivePartial<LlmModel.AsObject>);
    get name(): string;
    set name(value: string);
    get displayName(): string;
    set displayName(value: string);
    get description(): string;
    set description(value: string);
    get ccaiServiceName(): string;
    set ccaiServiceName(value: string);
    get ccaiServiceProvider(): ondewoNlu014.CcaiServiceProvider;
    set ccaiServiceProvider(value: ondewoNlu014.CcaiServiceProvider);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): LlmModel.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): LlmModel.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): LlmModel.AsProtobufJSON;
}
export declare namespace LlmModel {
    /**
     * Standard JavaScript object representation for LlmModel
     */
    interface AsObject {
        name: string;
        displayName: string;
        description: string;
        ccaiServiceName: string;
        ccaiServiceProvider: ondewoNlu014.CcaiServiceProvider;
    }
    /**
     * Protobuf JSON representation for LlmModel
     */
    interface AsProtobufJSON {
        name: string;
        displayName: string;
        description: string;
        ccaiServiceName: string;
        ccaiServiceProvider: string;
    }
}
/**
 * Message implementation for ondewo.nlu.LlmGenerateRequest
 */
export declare class LlmGenerateRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): LlmGenerateRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: LlmGenerateRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: LlmGenerateRequest, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: LlmGenerateRequest, _writer: BinaryWriter): void;
    private _llmGenerationRequest?;
    private _ccaiServiceName;
    private _fileResources?;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of LlmGenerateRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<LlmGenerateRequest.AsObject>);
    get llmGenerationRequest(): googleProtobuf003.Struct | undefined;
    set llmGenerationRequest(value: googleProtobuf003.Struct | undefined);
    get ccaiServiceName(): string;
    set ccaiServiceName(value: string);
    get fileResources(): ondewoNlu015.FileResource[] | undefined;
    set fileResources(value: ondewoNlu015.FileResource[] | undefined);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): LlmGenerateRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): LlmGenerateRequest.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): LlmGenerateRequest.AsProtobufJSON;
}
export declare namespace LlmGenerateRequest {
    /**
     * Standard JavaScript object representation for LlmGenerateRequest
     */
    interface AsObject {
        llmGenerationRequest?: googleProtobuf003.Struct.AsObject;
        ccaiServiceName: string;
        fileResources?: ondewoNlu015.FileResource.AsObject[];
    }
    /**
     * Protobuf JSON representation for LlmGenerateRequest
     */
    interface AsProtobufJSON {
        llmGenerationRequest: googleProtobuf003.Struct.AsProtobufJSON | null;
        ccaiServiceName: string;
        fileResources: ondewoNlu015.FileResource.AsProtobufJSON[] | null;
    }
}
/**
 * Message implementation for ondewo.nlu.LlmGenerateResponse
 */
export declare class LlmGenerateResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): LlmGenerateResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: LlmGenerateResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: LlmGenerateResponse, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: LlmGenerateResponse, _writer: BinaryWriter): void;
    private _llmGenerationResponse?;
    private _fileResources?;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of LlmGenerateResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<LlmGenerateResponse.AsObject>);
    get llmGenerationResponse(): googleProtobuf003.Struct | undefined;
    set llmGenerationResponse(value: googleProtobuf003.Struct | undefined);
    get fileResources(): ondewoNlu015.FileResource[] | undefined;
    set fileResources(value: ondewoNlu015.FileResource[] | undefined);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): LlmGenerateResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): LlmGenerateResponse.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): LlmGenerateResponse.AsProtobufJSON;
}
export declare namespace LlmGenerateResponse {
    /**
     * Standard JavaScript object representation for LlmGenerateResponse
     */
    interface AsObject {
        llmGenerationResponse?: googleProtobuf003.Struct.AsObject;
        fileResources?: ondewoNlu015.FileResource.AsObject[];
    }
    /**
     * Protobuf JSON representation for LlmGenerateResponse
     */
    interface AsProtobufJSON {
        llmGenerationResponse: googleProtobuf003.Struct.AsProtobufJSON | null;
        fileResources: ondewoNlu015.FileResource.AsProtobufJSON[] | null;
    }
}
/**
 * Message implementation for ondewo.nlu.StreamingLlmGenerateResponse
 */
export declare class StreamingLlmGenerateResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): StreamingLlmGenerateResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: StreamingLlmGenerateResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: StreamingLlmGenerateResponse, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: StreamingLlmGenerateResponse, _writer: BinaryWriter): void;
    private _llmGenerationStreamResponse?;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of StreamingLlmGenerateResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<StreamingLlmGenerateResponse.AsObject>);
    get llmGenerationStreamResponse(): googleProtobuf003.Struct | undefined;
    set llmGenerationStreamResponse(value: googleProtobuf003.Struct | undefined);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): StreamingLlmGenerateResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): StreamingLlmGenerateResponse.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): StreamingLlmGenerateResponse.AsProtobufJSON;
}
export declare namespace StreamingLlmGenerateResponse {
    /**
     * Standard JavaScript object representation for StreamingLlmGenerateResponse
     */
    interface AsObject {
        llmGenerationStreamResponse?: googleProtobuf003.Struct.AsObject;
    }
    /**
     * Protobuf JSON representation for StreamingLlmGenerateResponse
     */
    interface AsProtobufJSON {
        llmGenerationStreamResponse: googleProtobuf003.Struct.AsProtobufJSON | null;
    }
}
/**
 * Message implementation for ondewo.nlu.ExtractEntitiesRequest
 */
export declare class ExtractEntitiesRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ExtractEntitiesRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ExtractEntitiesRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ExtractEntitiesRequest, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: ExtractEntitiesRequest, _writer: BinaryWriter): void;
    private _parent;
    private _text;
    private _languageCode;
    private _intentName;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ExtractEntitiesRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<ExtractEntitiesRequest.AsObject>);
    get parent(): string;
    set parent(value: string);
    get text(): string;
    set text(value: string);
    get languageCode(): string;
    set languageCode(value: string);
    get intentName(): string;
    set intentName(value: string);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): ExtractEntitiesRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ExtractEntitiesRequest.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): ExtractEntitiesRequest.AsProtobufJSON;
}
export declare namespace ExtractEntitiesRequest {
    /**
     * Standard JavaScript object representation for ExtractEntitiesRequest
     */
    interface AsObject {
        parent: string;
        text: string;
        languageCode: string;
        intentName: string;
    }
    /**
     * Protobuf JSON representation for ExtractEntitiesRequest
     */
    interface AsProtobufJSON {
        parent: string;
        text: string;
        languageCode: string;
        intentName: string;
    }
}
/**
 * Message implementation for ondewo.nlu.ExtractEntitiesFuzzyRequest
 */
export declare class ExtractEntitiesFuzzyRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ExtractEntitiesFuzzyRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ExtractEntitiesFuzzyRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ExtractEntitiesFuzzyRequest, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: ExtractEntitiesFuzzyRequest, _writer: BinaryWriter): void;
    private _parent;
    private _text;
    private _potentialEntities?;
    private _minimalScore;
    private _allowOverlaps;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ExtractEntitiesFuzzyRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<ExtractEntitiesFuzzyRequest.AsObject>);
    get parent(): string;
    set parent(value: string);
    get text(): string;
    set text(value: string);
    get potentialEntities(): EntityTypeFuzzyNerConfig[] | undefined;
    set potentialEntities(value: EntityTypeFuzzyNerConfig[] | undefined);
    get minimalScore(): number;
    set minimalScore(value: number);
    get allowOverlaps(): boolean;
    set allowOverlaps(value: boolean);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): ExtractEntitiesFuzzyRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ExtractEntitiesFuzzyRequest.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): ExtractEntitiesFuzzyRequest.AsProtobufJSON;
}
export declare namespace ExtractEntitiesFuzzyRequest {
    /**
     * Standard JavaScript object representation for ExtractEntitiesFuzzyRequest
     */
    interface AsObject {
        parent: string;
        text: string;
        potentialEntities?: EntityTypeFuzzyNerConfig.AsObject[];
        minimalScore: number;
        allowOverlaps: boolean;
    }
    /**
     * Protobuf JSON representation for ExtractEntitiesFuzzyRequest
     */
    interface AsProtobufJSON {
        parent: string;
        text: string;
        potentialEntities: EntityTypeFuzzyNerConfig.AsProtobufJSON[] | null;
        minimalScore: number;
        allowOverlaps: boolean;
    }
}
/**
 * Message implementation for ondewo.nlu.EntityTypeFuzzyNerConfig
 */
export declare class EntityTypeFuzzyNerConfig implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): EntityTypeFuzzyNerConfig;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: EntityTypeFuzzyNerConfig): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: EntityTypeFuzzyNerConfig, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: EntityTypeFuzzyNerConfig, _writer: BinaryWriter): void;
    private _entityType?;
    private _minimalScore;
    private _entityValues;
    private _algorithm;
    private _allowOverlaps;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of EntityTypeFuzzyNerConfig to deeply clone from
     */
    constructor(_value?: RecursivePartial<EntityTypeFuzzyNerConfig.AsObject>);
    get entityType(): ondewoNlu013.EntityType | undefined;
    set entityType(value: ondewoNlu013.EntityType | undefined);
    get minimalScore(): number;
    set minimalScore(value: number);
    get entityValues(): string[];
    set entityValues(value: string[]);
    get algorithm(): EntityTypeFuzzyNerConfig.FuzzyNerAlgorithm;
    set algorithm(value: EntityTypeFuzzyNerConfig.FuzzyNerAlgorithm);
    get allowOverlaps(): boolean;
    set allowOverlaps(value: boolean);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): EntityTypeFuzzyNerConfig.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): EntityTypeFuzzyNerConfig.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): EntityTypeFuzzyNerConfig.AsProtobufJSON;
}
export declare namespace EntityTypeFuzzyNerConfig {
    /**
     * Standard JavaScript object representation for EntityTypeFuzzyNerConfig
     */
    interface AsObject {
        entityType?: ondewoNlu013.EntityType.AsObject;
        minimalScore: number;
        entityValues: string[];
        algorithm: EntityTypeFuzzyNerConfig.FuzzyNerAlgorithm;
        allowOverlaps: boolean;
    }
    /**
     * Protobuf JSON representation for EntityTypeFuzzyNerConfig
     */
    interface AsProtobufJSON {
        entityType: ondewoNlu013.EntityType.AsProtobufJSON | null;
        minimalScore: number;
        entityValues: string[];
        algorithm: string;
        allowOverlaps: boolean;
    }
    enum FuzzyNerAlgorithm {
        PREFILTER_LEVENSHTEIN = 0,
        LOCAL_MAXIMUM = 1
    }
}
/**
 * Message implementation for ondewo.nlu.EntityDetected
 */
export declare class EntityDetected implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): EntityDetected;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: EntityDetected): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: EntityDetected, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: EntityDetected, _writer: BinaryWriter): void;
    private _entity?;
    private _extractionMethod;
    private _score;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of EntityDetected to deeply clone from
     */
    constructor(_value?: RecursivePartial<EntityDetected.AsObject>);
    get entity(): ondewoNlu012.Intent.TrainingPhrase.Entity | undefined;
    set entity(value: ondewoNlu012.Intent.TrainingPhrase.Entity | undefined);
    get extractionMethod(): string;
    set extractionMethod(value: string);
    get score(): number;
    set score(value: number);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): EntityDetected.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): EntityDetected.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): EntityDetected.AsProtobufJSON;
}
export declare namespace EntityDetected {
    /**
     * Standard JavaScript object representation for EntityDetected
     */
    interface AsObject {
        entity?: ondewoNlu012.Intent.TrainingPhrase.Entity.AsObject;
        extractionMethod: string;
        score: number;
    }
    /**
     * Protobuf JSON representation for EntityDetected
     */
    interface AsProtobufJSON {
        entity: ondewoNlu012.Intent.TrainingPhrase.Entity.AsProtobufJSON | null;
        extractionMethod: string;
        score: number;
    }
}
/**
 * Message implementation for ondewo.nlu.ExtractEntitiesResponse
 */
export declare class ExtractEntitiesResponse implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): ExtractEntitiesResponse;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: ExtractEntitiesResponse): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: ExtractEntitiesResponse, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: ExtractEntitiesResponse, _writer: BinaryWriter): void;
    private _entitiesDetected?;
    private _text;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of ExtractEntitiesResponse to deeply clone from
     */
    constructor(_value?: RecursivePartial<ExtractEntitiesResponse.AsObject>);
    get entitiesDetected(): EntityDetected[] | undefined;
    set entitiesDetected(value: EntityDetected[] | undefined);
    get text(): string;
    set text(value: string);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): ExtractEntitiesResponse.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): ExtractEntitiesResponse.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): ExtractEntitiesResponse.AsProtobufJSON;
}
export declare namespace ExtractEntitiesResponse {
    /**
     * Standard JavaScript object representation for ExtractEntitiesResponse
     */
    interface AsObject {
        entitiesDetected?: EntityDetected.AsObject[];
        text: string;
    }
    /**
     * Protobuf JSON representation for ExtractEntitiesResponse
     */
    interface AsProtobufJSON {
        entitiesDetected: EntityDetected.AsProtobufJSON[] | null;
        text: string;
    }
}
/**
 * Message implementation for ondewo.nlu.GetAlternativeSentencesRequest
 */
export declare class GetAlternativeSentencesRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): GetAlternativeSentencesRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: GetAlternativeSentencesRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: GetAlternativeSentencesRequest, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: GetAlternativeSentencesRequest, _writer: BinaryWriter): void;
    private _config?;
    private _sentence;
    private _languageCode;
    private _parent;
    private _protectedWords;
    private _wordsToChange;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of GetAlternativeSentencesRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<GetAlternativeSentencesRequest.AsObject>);
    get config(): DataEnrichmentConfig | undefined;
    set config(value: DataEnrichmentConfig | undefined);
    get sentence(): string;
    set sentence(value: string);
    get languageCode(): string;
    set languageCode(value: string);
    get parent(): string;
    set parent(value: string);
    get protectedWords(): string[];
    set protectedWords(value: string[]);
    get wordsToChange(): string[];
    set wordsToChange(value: string[]);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): GetAlternativeSentencesRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): GetAlternativeSentencesRequest.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): GetAlternativeSentencesRequest.AsProtobufJSON;
}
export declare namespace GetAlternativeSentencesRequest {
    /**
     * Standard JavaScript object representation for GetAlternativeSentencesRequest
     */
    interface AsObject {
        config?: DataEnrichmentConfig.AsObject;
        sentence: string;
        languageCode: string;
        parent: string;
        protectedWords: string[];
        wordsToChange: string[];
    }
    /**
     * Protobuf JSON representation for GetAlternativeSentencesRequest
     */
    interface AsProtobufJSON {
        config: DataEnrichmentConfig.AsProtobufJSON | null;
        sentence: string;
        languageCode: string;
        parent: string;
        protectedWords: string[];
        wordsToChange: string[];
    }
}
/**
 * Message implementation for ondewo.nlu.GenerateUserSaysRequest
 */
export declare class GenerateUserSaysRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): GenerateUserSaysRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: GenerateUserSaysRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: GenerateUserSaysRequest, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: GenerateUserSaysRequest, _writer: BinaryWriter): void;
    private _languageCode;
    private _parent;
    private _nRepeatSynonym;
    private _branch;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of GenerateUserSaysRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<GenerateUserSaysRequest.AsObject>);
    get languageCode(): string;
    set languageCode(value: string);
    get parent(): string;
    set parent(value: string);
    get nRepeatSynonym(): number;
    set nRepeatSynonym(value: number);
    get branch(): string;
    set branch(value: string);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): GenerateUserSaysRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): GenerateUserSaysRequest.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): GenerateUserSaysRequest.AsProtobufJSON;
}
export declare namespace GenerateUserSaysRequest {
    /**
     * Standard JavaScript object representation for GenerateUserSaysRequest
     */
    interface AsObject {
        languageCode: string;
        parent: string;
        nRepeatSynonym: number;
        branch: string;
    }
    /**
     * Protobuf JSON representation for GenerateUserSaysRequest
     */
    interface AsProtobufJSON {
        languageCode: string;
        parent: string;
        nRepeatSynonym: number;
        branch: string;
    }
}
/**
 * Message implementation for ondewo.nlu.GenerateResponsesRequest
 */
export declare class GenerateResponsesRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): GenerateResponsesRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: GenerateResponsesRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: GenerateResponsesRequest, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: GenerateResponsesRequest, _writer: BinaryWriter): void;
    private _languageCode;
    private _parent;
    private _nRepeatSynonym;
    private _branch;
    private _dropUnknownParameters;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of GenerateResponsesRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<GenerateResponsesRequest.AsObject>);
    get languageCode(): string;
    set languageCode(value: string);
    get parent(): string;
    set parent(value: string);
    get nRepeatSynonym(): number;
    set nRepeatSynonym(value: number);
    get branch(): string;
    set branch(value: string);
    get dropUnknownParameters(): boolean;
    set dropUnknownParameters(value: boolean);
    /**
     * Serialize message to binary data
     * @param instance message instance
     */
    serializeBinary(): any;
    /**
     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
     */
    toObject(): GenerateResponsesRequest.AsObject;
    /**
     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
     */
    toJSON(): GenerateResponsesRequest.AsObject;
    /**
     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
     */
    toProtobufJSON(options?: ToProtobufJSONOptions): GenerateResponsesRequest.AsProtobufJSON;
}
export declare namespace GenerateResponsesRequest {
    /**
     * Standard JavaScript object representation for GenerateResponsesRequest
     */
    interface AsObject {
        languageCode: string;
        parent: string;
        nRepeatSynonym: number;
        branch: string;
        dropUnknownParameters: boolean;
    }
    /**
     * Protobuf JSON representation for GenerateResponsesRequest
     */
    interface AsProtobufJSON {
        languageCode: string;
        parent: string;
        nRepeatSynonym: number;
        branch: string;
        dropUnknownParameters: boolean;
    }
}
/**
 * Message implementation for ondewo.nlu.GetAlternativeTrainingPhrasesRequest
 */
export declare class GetAlternativeTrainingPhrasesRequest implements GrpcMessage {
    static id: string;
    /**
     * Deserialize binary data to message
     * @param instance message instance
     */
    static deserializeBinary(bytes: ByteSource): GetAlternativeTrainingPhrasesRequest;
    /**
     * Check all the properties and set default protobuf values if necessary
     * @param _instance message instance
     */
    static refineValues(_instance: GetAlternativeTrainingPhrasesRequest): void;
    /**
     * Deserializes / reads binary message into message instance using provided binary reader
     * @param _instance message instance
     * @param _reader binary reader instance
     */
    static deserializeBinaryFromReader(_instance: GetAlternativeTrainingPhrasesRequest, _reader: BinaryReader): void;
    /**
     * Serializes a message to binary format using provided binary reader
     * @param _instance message instance
     * @param _writer binary writer instance
     */
    static serializeBinaryToWriter(_instance: GetAlternativeTrainingPhrasesRequest, _writer: BinaryWriter): void;
    private _config?;
    private _trainingPhrase?;
    private _intentName;
    private _languageCode;
    private _parent;
    private _detectEntities;
    private _similarityThreshold;
    private _protectedWords;
    private _wordsToChange;
    private _branch;
    /**
     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
     * @param _value initial values object or instance of GetAlternativeTrainingPhrasesRequest to deeply clone from
     */
    constructor(_value?: RecursivePartial<GetAlternativeTrainingPhrasesRequest.AsObject>);
    get config(): DataEnrichmentConfig | undefined;
    set config(value: DataEnrichmentConfig | undefined);
    get trainingPhrase(): ondewoNlu012.Intent.TrainingPhrase | undefined;
    set trainingPhrase(value: ondewoNlu012.Intent.TrainingPhrase | undefined);
    get intentName(): string;
    set intentName(value: string);
    get languageCode(): string;
    set languageCode(value: string);
    get parent(): string;
    set parent(value: string);
    get detectEntities(): boolean;
    set detectEntities(value: boolean);
    get similarityThreshold(): number;
    set simi