// Copyright 2026 LiveKit, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// @generated by protoc-gen-es v1.10.1 with parameter "target=dts+js"
// @generated from file agent/livekit_agent_inference.proto (package livekit.agent, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, Duration, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage, Timestamp } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import type { ChatMessage } from "./livekit_agent_session_pb.js";

/**
 * @generated from enum livekit.agent.AudioEncoding
 */
export declare enum AudioEncoding {
  /**
   * @generated from enum value: AUDIO_ENCODING_PCM_S16LE = 0;
   */
  PCM_S16LE = 0,

  /**
   * @generated from enum value: AUDIO_ENCODING_OPUS = 1;
   */
  OPUS = 1,
}

/**
 * @generated from message livekit.agent.SessionSettings
 */
export declare class SessionSettings extends Message<SessionSettings> {
  /**
   * @generated from field: uint32 sample_rate = 1;
   */
  sampleRate: number;

  /**
   * @generated from field: livekit.agent.AudioEncoding encoding = 2;
   */
  encoding: AudioEncoding;

  /**
   * @generated from oneof livekit.agent.SessionSettings.type_settings
   */
  typeSettings: {
    /**
     * @generated from field: livekit.agent.EotSettings eot_settings = 3;
     */
    value: EotSettings;
    case: "eotSettings";
  } | {
    /**
     * @generated from field: livekit.agent.InterruptionSettings interruption_settings = 4;
     */
    value: InterruptionSettings;
    case: "interruptionSettings";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<SessionSettings>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.SessionSettings";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionSettings;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionSettings;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionSettings;

  static equals(a: SessionSettings | PlainMessage<SessionSettings> | undefined, b: SessionSettings | PlainMessage<SessionSettings> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InferenceError
 */
export declare class InferenceError extends Message<InferenceError> {
  /**
   * @generated from field: string message = 1;
   */
  message: string;

  /**
   * error code follows the HTTP status code convention
   * 4xx for client errors
   * 5xx for server errors
   *
   * @generated from field: uint32 code = 2;
   */
  code: number;

  constructor(data?: PartialMessage<InferenceError>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InferenceError";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceError;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceError;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceError;

  static equals(a: InferenceError | PlainMessage<InferenceError> | undefined, b: InferenceError | PlainMessage<InferenceError> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.EotSettings
 */
export declare class EotSettings extends Message<EotSettings> {
  /**
   * @generated from field: google.protobuf.Duration detection_interval = 1;
   */
  detectionInterval?: Duration;

  constructor(data?: PartialMessage<EotSettings>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.EotSettings";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EotSettings;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EotSettings;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EotSettings;

  static equals(a: EotSettings | PlainMessage<EotSettings> | undefined, b: EotSettings | PlainMessage<EotSettings> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InterruptionSettings
 */
export declare class InterruptionSettings extends Message<InterruptionSettings> {
  /**
   * detection threshold in range [0.0, 1.0]; higher values are less sensitive
   *
   * @generated from field: float threshold = 1;
   */
  threshold: number;

  /**
   * minimum number of frames with probability greater than threshold to trigger an interruption
   *
   * @generated from field: uint32 min_frames = 2;
   */
  minFrames: number;

  /**
   * @generated from field: google.protobuf.Duration max_audio_duration = 3;
   */
  maxAudioDuration?: Duration;

  /**
   * @generated from field: google.protobuf.Duration audio_prefix_duration = 4;
   */
  audioPrefixDuration?: Duration;

  /**
   * @generated from field: google.protobuf.Duration detection_interval = 5;
   */
  detectionInterval?: Duration;

  constructor(data?: PartialMessage<InterruptionSettings>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InterruptionSettings";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InterruptionSettings;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InterruptionSettings;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InterruptionSettings;

  static equals(a: InterruptionSettings | PlainMessage<InterruptionSettings> | undefined, b: InterruptionSettings | PlainMessage<InterruptionSettings> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.SessionCreate
 */
export declare class SessionCreate extends Message<SessionCreate> {
  /**
   * @generated from field: livekit.agent.SessionSettings settings = 1;
   */
  settings?: SessionSettings;

  constructor(data?: PartialMessage<SessionCreate>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.SessionCreate";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionCreate;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionCreate;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionCreate;

  static equals(a: SessionCreate | PlainMessage<SessionCreate> | undefined, b: SessionCreate | PlainMessage<SessionCreate> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InputAudio
 */
export declare class InputAudio extends Message<InputAudio> {
  /**
   * @generated from field: bytes audio = 1;
   */
  audio: Uint8Array;

  /**
   * @generated from field: google.protobuf.Timestamp created_at = 2;
   */
  createdAt?: Timestamp;

  /**
   * @generated from field: uint32 num_samples = 3;
   */
  numSamples: number;

  constructor(data?: PartialMessage<InputAudio>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InputAudio";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InputAudio;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InputAudio;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InputAudio;

  static equals(a: InputAudio | PlainMessage<InputAudio> | undefined, b: InputAudio | PlainMessage<InputAudio> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.EotInputChatContext
 */
export declare class EotInputChatContext extends Message<EotInputChatContext> {
  /**
   * @generated from field: repeated livekit.agent.ChatMessage messages = 1;
   */
  messages: ChatMessage[];

  constructor(data?: PartialMessage<EotInputChatContext>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.EotInputChatContext";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EotInputChatContext;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EotInputChatContext;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EotInputChatContext;

  static equals(a: EotInputChatContext | PlainMessage<EotInputChatContext> | undefined, b: EotInputChatContext | PlainMessage<EotInputChatContext> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.SessionFlush
 */
export declare class SessionFlush extends Message<SessionFlush> {
  constructor(data?: PartialMessage<SessionFlush>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.SessionFlush";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionFlush;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionFlush;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionFlush;

  static equals(a: SessionFlush | PlainMessage<SessionFlush> | undefined, b: SessionFlush | PlainMessage<SessionFlush> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.SessionClose
 */
export declare class SessionClose extends Message<SessionClose> {
  constructor(data?: PartialMessage<SessionClose>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.SessionClose";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionClose;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionClose;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionClose;

  static equals(a: SessionClose | PlainMessage<SessionClose> | undefined, b: SessionClose | PlainMessage<SessionClose> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InferenceStart
 */
export declare class InferenceStart extends Message<InferenceStart> {
  /**
   * @generated from field: string request_id = 1;
   */
  requestId: string;

  constructor(data?: PartialMessage<InferenceStart>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InferenceStart";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceStart;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceStart;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceStart;

  static equals(a: InferenceStart | PlainMessage<InferenceStart> | undefined, b: InferenceStart | PlainMessage<InferenceStart> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InferenceStop
 */
export declare class InferenceStop extends Message<InferenceStop> {
  /**
   * @generated from field: string request_id = 1;
   */
  requestId: string;

  constructor(data?: PartialMessage<InferenceStop>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InferenceStop";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceStop;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceStop;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceStop;

  static equals(a: InferenceStop | PlainMessage<InferenceStop> | undefined, b: InferenceStop | PlainMessage<InferenceStop> | undefined): boolean;
}

/**
 * audio buffer sentinel messages
 *
 * @generated from message livekit.agent.BufferStart
 */
export declare class BufferStart extends Message<BufferStart> {
  constructor(data?: PartialMessage<BufferStart>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.BufferStart";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BufferStart;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BufferStart;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BufferStart;

  static equals(a: BufferStart | PlainMessage<BufferStart> | undefined, b: BufferStart | PlainMessage<BufferStart> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.BufferStop
 */
export declare class BufferStop extends Message<BufferStop> {
  constructor(data?: PartialMessage<BufferStop>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.BufferStop";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BufferStop;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BufferStop;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BufferStop;

  static equals(a: BufferStop | PlainMessage<BufferStop> | undefined, b: BufferStop | PlainMessage<BufferStop> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.ClientMessage
 */
export declare class ClientMessage extends Message<ClientMessage> {
  /**
   * @generated from field: google.protobuf.Timestamp created_at = 1;
   */
  createdAt?: Timestamp;

  /**
   * @generated from oneof livekit.agent.ClientMessage.message
   */
  message: {
    /**
     * @generated from field: livekit.agent.SessionCreate session_create = 2;
     */
    value: SessionCreate;
    case: "sessionCreate";
  } | {
    /**
     * @generated from field: livekit.agent.InputAudio input_audio = 3;
     */
    value: InputAudio;
    case: "inputAudio";
  } | {
    /**
     * @generated from field: livekit.agent.SessionFlush session_flush = 4;
     */
    value: SessionFlush;
    case: "sessionFlush";
  } | {
    /**
     * @generated from field: livekit.agent.SessionClose session_close = 5;
     */
    value: SessionClose;
    case: "sessionClose";
  } | {
    /**
     * @generated from field: livekit.agent.InferenceStart inference_start = 6;
     */
    value: InferenceStart;
    case: "inferenceStart";
  } | {
    /**
     * @generated from field: livekit.agent.InferenceStop inference_stop = 7;
     */
    value: InferenceStop;
    case: "inferenceStop";
  } | {
    /**
     * @generated from field: livekit.agent.BufferStart buffer_start = 8;
     */
    value: BufferStart;
    case: "bufferStart";
  } | {
    /**
     * @generated from field: livekit.agent.BufferStop buffer_stop = 9;
     */
    value: BufferStop;
    case: "bufferStop";
  } | {
    /**
     * only for end of turn
     *
     * @generated from field: livekit.agent.EotInputChatContext eot_input_chat_context = 10;
     */
    value: EotInputChatContext;
    case: "eotInputChatContext";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<ClientMessage>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.ClientMessage";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientMessage;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientMessage;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientMessage;

  static equals(a: ClientMessage | PlainMessage<ClientMessage> | undefined, b: ClientMessage | PlainMessage<ClientMessage> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.EotInferenceRequest
 */
export declare class EotInferenceRequest extends Message<EotInferenceRequest> {
  /**
   * @generated from field: bytes audio = 1;
   */
  audio: Uint8Array;

  /**
   * @generated from field: string assistant_text = 2;
   */
  assistantText: string;

  /**
   * @generated from field: livekit.agent.AudioEncoding encoding = 3;
   */
  encoding: AudioEncoding;

  /**
   * @generated from field: uint32 sample_rate = 4;
   */
  sampleRate: number;

  constructor(data?: PartialMessage<EotInferenceRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.EotInferenceRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EotInferenceRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EotInferenceRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EotInferenceRequest;

  static equals(a: EotInferenceRequest | PlainMessage<EotInferenceRequest> | undefined, b: EotInferenceRequest | PlainMessage<EotInferenceRequest> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InterruptionInferenceRequest
 */
export declare class InterruptionInferenceRequest extends Message<InterruptionInferenceRequest> {
  /**
   * @generated from field: bytes audio = 1;
   */
  audio: Uint8Array;

  /**
   * @generated from field: livekit.agent.AudioEncoding encoding = 2;
   */
  encoding: AudioEncoding;

  /**
   * @generated from field: uint32 sample_rate = 3;
   */
  sampleRate: number;

  constructor(data?: PartialMessage<InterruptionInferenceRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InterruptionInferenceRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InterruptionInferenceRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InterruptionInferenceRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InterruptionInferenceRequest;

  static equals(a: InterruptionInferenceRequest | PlainMessage<InterruptionInferenceRequest> | undefined, b: InterruptionInferenceRequest | PlainMessage<InterruptionInferenceRequest> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InferenceRequest
 */
export declare class InferenceRequest extends Message<InferenceRequest> {
  /**
   * @generated from oneof livekit.agent.InferenceRequest.request
   */
  request: {
    /**
     * @generated from field: livekit.agent.EotInferenceRequest eot_inference_request = 1;
     */
    value: EotInferenceRequest;
    case: "eotInferenceRequest";
  } | {
    /**
     * @generated from field: livekit.agent.InterruptionInferenceRequest interruption_inference_request = 2;
     */
    value: InterruptionInferenceRequest;
    case: "interruptionInferenceRequest";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<InferenceRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InferenceRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceRequest;

  static equals(a: InferenceRequest | PlainMessage<InferenceRequest> | undefined, b: InferenceRequest | PlainMessage<InferenceRequest> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InferenceStats
 */
export declare class InferenceStats extends Message<InferenceStats> {
  /**
   * proxy -> model: audio window timestamps
   *
   * @generated from field: optional google.protobuf.Timestamp earliest_client_created_at = 1;
   */
  earliestClientCreatedAt?: Timestamp;

  /**
   * @generated from field: optional google.protobuf.Timestamp latest_client_created_at = 2;
   */
  latestClientCreatedAt?: Timestamp;

  /**
   * proxy side e2e latency (proxy send -> proxy receive)
   *
   * @generated from field: optional google.protobuf.Duration client_e2e_latency = 3;
   */
  clientE2eLatency?: Duration;

  /**
   * model side e2e latency (model endpoint receive -> model endpoint return)
   *
   * @generated from field: google.protobuf.Duration server_e2e_latency = 4;
   */
  serverE2eLatency?: Duration;

  /**
   * model side inference stats
   *
   * @generated from field: google.protobuf.Duration preprocessing_duration = 5;
   */
  preprocessingDuration?: Duration;

  /**
   * @generated from field: google.protobuf.Duration inference_duration = 6;
   */
  inferenceDuration?: Duration;

  constructor(data?: PartialMessage<InferenceStats>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InferenceStats";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceStats;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceStats;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceStats;

  static equals(a: InferenceStats | PlainMessage<InferenceStats> | undefined, b: InferenceStats | PlainMessage<InferenceStats> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.EotInferenceResponse
 */
export declare class EotInferenceResponse extends Message<EotInferenceResponse> {
  /**
   * @generated from field: float probability = 1;
   */
  probability: number;

  /**
   * @generated from field: livekit.agent.InferenceStats stats = 2;
   */
  stats?: InferenceStats;

  constructor(data?: PartialMessage<EotInferenceResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.EotInferenceResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EotInferenceResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EotInferenceResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EotInferenceResponse;

  static equals(a: EotInferenceResponse | PlainMessage<EotInferenceResponse> | undefined, b: EotInferenceResponse | PlainMessage<EotInferenceResponse> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InterruptionInferenceResponse
 */
export declare class InterruptionInferenceResponse extends Message<InterruptionInferenceResponse> {
  /**
   * @generated from field: bool is_interruption = 1;
   */
  isInterruption: boolean;

  /**
   * per frame probabilities
   *
   * @generated from field: repeated float probabilities = 2;
   */
  probabilities: number[];

  /**
   * @generated from field: livekit.agent.InferenceStats stats = 3;
   */
  stats?: InferenceStats;

  constructor(data?: PartialMessage<InterruptionInferenceResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InterruptionInferenceResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InterruptionInferenceResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InterruptionInferenceResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InterruptionInferenceResponse;

  static equals(a: InterruptionInferenceResponse | PlainMessage<InterruptionInferenceResponse> | undefined, b: InterruptionInferenceResponse | PlainMessage<InterruptionInferenceResponse> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InferenceResponse
 */
export declare class InferenceResponse extends Message<InferenceResponse> {
  /**
   * @generated from oneof livekit.agent.InferenceResponse.response
   */
  response: {
    /**
     * @generated from field: livekit.agent.EotInferenceResponse eot_inference_response = 1;
     */
    value: EotInferenceResponse;
    case: "eotInferenceResponse";
  } | {
    /**
     * @generated from field: livekit.agent.InterruptionInferenceResponse interruption_inference_response = 2;
     */
    value: InterruptionInferenceResponse;
    case: "interruptionInferenceResponse";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<InferenceResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InferenceResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceResponse;

  static equals(a: InferenceResponse | PlainMessage<InferenceResponse> | undefined, b: InferenceResponse | PlainMessage<InferenceResponse> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.SessionCreated
 */
export declare class SessionCreated extends Message<SessionCreated> {
  /**
   * Server-recommended default detection thresholds keyed by language code
   * (e.g. "en", "es"). The threshold semantics match the session type: EOT
   * probability threshold for EOT sessions, interruption threshold for
   * barge-in sessions.
   *
   * @generated from field: map<string, float> default_thresholds = 1;
   */
  defaultThresholds: { [key: string]: number };

  /**
   * Catch-all default applied to languages not present in default_thresholds.
   *
   * @generated from field: float default_threshold = 2;
   */
  defaultThreshold: number;

  /**
   * same structure, but for backchannel
   *
   * @generated from field: map<string, float> default_backchannel_thresholds = 3;
   */
  defaultBackchannelThresholds: { [key: string]: number };

  /**
   * @generated from field: float default_backchannel_threshold = 4;
   */
  defaultBackchannelThreshold: number;

  constructor(data?: PartialMessage<SessionCreated>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.SessionCreated";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionCreated;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionCreated;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionCreated;

  static equals(a: SessionCreated | PlainMessage<SessionCreated> | undefined, b: SessionCreated | PlainMessage<SessionCreated> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InferenceStarted
 */
export declare class InferenceStarted extends Message<InferenceStarted> {
  constructor(data?: PartialMessage<InferenceStarted>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InferenceStarted";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceStarted;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceStarted;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceStarted;

  static equals(a: InferenceStarted | PlainMessage<InferenceStarted> | undefined, b: InferenceStarted | PlainMessage<InferenceStarted> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.InferenceStopped
 */
export declare class InferenceStopped extends Message<InferenceStopped> {
  constructor(data?: PartialMessage<InferenceStopped>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InferenceStopped";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceStopped;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceStopped;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceStopped;

  static equals(a: InferenceStopped | PlainMessage<InferenceStopped> | undefined, b: InferenceStopped | PlainMessage<InferenceStopped> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.SessionClosed
 */
export declare class SessionClosed extends Message<SessionClosed> {
  constructor(data?: PartialMessage<SessionClosed>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.SessionClosed";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionClosed;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionClosed;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionClosed;

  static equals(a: SessionClosed | PlainMessage<SessionClosed> | undefined, b: SessionClosed | PlainMessage<SessionClosed> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.EotPrediction
 */
export declare class EotPrediction extends Message<EotPrediction> {
  /**
   * @generated from field: float probability = 1;
   */
  probability: number;

  /**
   * @generated from field: livekit.agent.InferenceStats inference_stats = 2;
   */
  inferenceStats?: InferenceStats;

  /**
   * @generated from field: livekit.agent.EotPrediction.EotBackend backend = 3;
   */
  backend: EotPrediction_EotBackend;

  /**
   * @generated from field: float backchannel_probability = 4;
   */
  backchannelProbability: number;

  constructor(data?: PartialMessage<EotPrediction>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.EotPrediction";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EotPrediction;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EotPrediction;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EotPrediction;

  static equals(a: EotPrediction | PlainMessage<EotPrediction> | undefined, b: EotPrediction | PlainMessage<EotPrediction> | undefined): boolean;
}

/**
 * @generated from enum livekit.agent.EotPrediction.EotBackend
 */
export declare enum EotPrediction_EotBackend {
  /**
   * @generated from enum value: EOT_BACKEND_UNKNOWN = 0;
   */
  UNKNOWN = 0,

  /**
   * @generated from enum value: EOT_BACKEND_MULTIMODAL = 1;
   */
  MULTIMODAL = 1,

  /**
   * @generated from enum value: EOT_BACKEND_TEXT = 2;
   */
  TEXT = 2,
}

/**
 * @generated from message livekit.agent.InterruptionPrediction
 */
export declare class InterruptionPrediction extends Message<InterruptionPrediction> {
  /**
   * @generated from field: bool is_interruption = 1;
   */
  isInterruption: boolean;

  /**
   * @generated from field: repeated float probabilities = 2;
   */
  probabilities: number[];

  /**
   * @generated from field: livekit.agent.InferenceStats inference_stats = 3;
   */
  inferenceStats?: InferenceStats;

  constructor(data?: PartialMessage<InterruptionPrediction>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.InterruptionPrediction";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InterruptionPrediction;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InterruptionPrediction;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InterruptionPrediction;

  static equals(a: InterruptionPrediction | PlainMessage<InterruptionPrediction> | undefined, b: InterruptionPrediction | PlainMessage<InterruptionPrediction> | undefined): boolean;
}

/**
 * @generated from message livekit.agent.ServerMessage
 */
export declare class ServerMessage extends Message<ServerMessage> {
  /**
   * @generated from field: google.protobuf.Timestamp server_created_at = 1;
   */
  serverCreatedAt?: Timestamp;

  /**
   * @generated from field: optional string request_id = 2;
   */
  requestId?: string;

  /**
   * echoes the client-side created_at timestamp
   *
   * @generated from field: optional google.protobuf.Timestamp client_created_at = 3;
   */
  clientCreatedAt?: Timestamp;

  /**
   * @generated from oneof livekit.agent.ServerMessage.message
   */
  message: {
    /**
     * @generated from field: livekit.agent.SessionCreated session_created = 4;
     */
    value: SessionCreated;
    case: "sessionCreated";
  } | {
    /**
     * @generated from field: livekit.agent.InferenceStarted inference_started = 5;
     */
    value: InferenceStarted;
    case: "inferenceStarted";
  } | {
    /**
     * @generated from field: livekit.agent.InferenceStopped inference_stopped = 6;
     */
    value: InferenceStopped;
    case: "inferenceStopped";
  } | {
    /**
     * @generated from field: livekit.agent.SessionClosed session_closed = 7;
     */
    value: SessionClosed;
    case: "sessionClosed";
  } | {
    /**
     * @generated from field: livekit.agent.InferenceError error = 8;
     */
    value: InferenceError;
    case: "error";
  } | {
    /**
     * @generated from field: livekit.agent.EotPrediction eot_prediction = 9;
     */
    value: EotPrediction;
    case: "eotPrediction";
  } | {
    /**
     * @generated from field: livekit.agent.InterruptionPrediction interruption_prediction = 10;
     */
    value: InterruptionPrediction;
    case: "interruptionPrediction";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<ServerMessage>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "livekit.agent.ServerMessage";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ServerMessage;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ServerMessage;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ServerMessage;

  static equals(a: ServerMessage | PlainMessage<ServerMessage> | undefined, b: ServerMessage | PlainMessage<ServerMessage> | undefined): boolean;
}

