// Copyright 2025 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 "js_import_style=legacy_commonjs"
// @generated from file video_frame.proto (package livekit.proto, syntax proto2)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto2 } from "@bufbuild/protobuf";
import type { TrackSource } from "./track_pb.js";
import type { FfiOwnedHandle } from "./handle_pb.js";

/**
 * @generated from enum livekit.proto.VideoCodec
 */
export declare enum VideoCodec {
  /**
   * @generated from enum value: VP8 = 0;
   */
  VP8 = 0,

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

  /**
   * @generated from enum value: AV1 = 2;
   */
  AV1 = 2,

  /**
   * @generated from enum value: VP9 = 3;
   */
  VP9 = 3,

  /**
   * @generated from enum value: H265 = 4;
   */
  H265 = 4,
}

/**
 * @generated from enum livekit.proto.VideoRotation
 */
export declare enum VideoRotation {
  /**
   * @generated from enum value: VIDEO_ROTATION_0 = 0;
   */
  VIDEO_ROTATION_0 = 0,

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

  /**
   * @generated from enum value: VIDEO_ROTATION_180 = 2;
   */
  VIDEO_ROTATION_180 = 2,

  /**
   * @generated from enum value: VIDEO_ROTATION_270 = 3;
   */
  VIDEO_ROTATION_270 = 3,
}

/**
 * Values of this enum must not be changed
 * It is used to serialize a rtc.VideoFrame on Python
 *
 * @generated from enum livekit.proto.VideoBufferType
 */
export declare enum VideoBufferType {
  /**
   * @generated from enum value: RGBA = 0;
   */
  RGBA = 0,

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

  /**
   * @generated from enum value: ARGB = 2;
   */
  ARGB = 2,

  /**
   * @generated from enum value: BGRA = 3;
   */
  BGRA = 3,

  /**
   * @generated from enum value: RGB24 = 4;
   */
  RGB24 = 4,

  /**
   * @generated from enum value: I420 = 5;
   */
  I420 = 5,

  /**
   * @generated from enum value: I420A = 6;
   */
  I420A = 6,

  /**
   * @generated from enum value: I422 = 7;
   */
  I422 = 7,

  /**
   * @generated from enum value: I444 = 8;
   */
  I444 = 8,

  /**
   * @generated from enum value: I010 = 9;
   */
  I010 = 9,

  /**
   * @generated from enum value: NV12 = 10;
   */
  NV12 = 10,
}

/**
 * @generated from enum livekit.proto.VideoStreamType
 */
export declare enum VideoStreamType {
  /**
   * @generated from enum value: VIDEO_STREAM_NATIVE = 0;
   */
  VIDEO_STREAM_NATIVE = 0,

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

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

/**
 * @generated from enum livekit.proto.VideoSourceType
 */
export declare enum VideoSourceType {
  /**
   * @generated from enum value: VIDEO_SOURCE_NATIVE = 0;
   */
  VIDEO_SOURCE_NATIVE = 0,
}

/**
 * Create a new VideoStream
 * VideoStream is used to receive video frames from a track
 *
 * @generated from message livekit.proto.NewVideoStreamRequest
 */
export declare class NewVideoStreamRequest extends Message<NewVideoStreamRequest> {
  /**
   * @generated from field: required uint64 track_handle = 1;
   */
  trackHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.VideoStreamType type = 2;
   */
  type?: VideoStreamType;

  /**
   * Get the frame on a specific format
   *
   * @generated from field: optional livekit.proto.VideoBufferType format = 3;
   */
  format?: VideoBufferType;

  /**
   * if true, stride will be set to width/chroma_width
   *
   * @generated from field: optional bool normalize_stride = 4;
   */
  normalizeStride?: boolean;

  /**
   * Maximum number of queued WebRTC sink frames on the receive path. Omit this
   * field to use the default bounded queue size of 1 frame. Set it to 0 to
   * request unbounded buffering.
   *
   * If your application consumes both audio and video, keep the queue sizing
   * strategy coordinated across both streams. Using a much larger queue, or
   * unbounded buffering, for only one of them can increase end-to-end latency
   * for that stream and cause audio/video drift.
   *
   * @generated from field: optional uint32 queue_size_frames = 5;
   */
  queueSizeFrames?: number;

  constructor(data?: PartialMessage<NewVideoStreamRequest>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.NewVideoStreamRequest";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.NewVideoStreamResponse
 */
export declare class NewVideoStreamResponse extends Message<NewVideoStreamResponse> {
  /**
   * @generated from field: required livekit.proto.OwnedVideoStream stream = 1;
   */
  stream?: OwnedVideoStream;

  constructor(data?: PartialMessage<NewVideoStreamResponse>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.NewVideoStreamResponse";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Request a video stream from a participant
 *
 * @generated from message livekit.proto.VideoStreamFromParticipantRequest
 */
export declare class VideoStreamFromParticipantRequest extends Message<VideoStreamFromParticipantRequest> {
  /**
   * @generated from field: required uint64 participant_handle = 1;
   */
  participantHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.VideoStreamType type = 2;
   */
  type?: VideoStreamType;

  /**
   * @generated from field: required livekit.proto.TrackSource track_source = 3;
   */
  trackSource?: TrackSource;

  /**
   * @generated from field: optional livekit.proto.VideoBufferType format = 4;
   */
  format?: VideoBufferType;

  /**
   * @generated from field: optional bool normalize_stride = 5;
   */
  normalizeStride?: boolean;

  /**
   * Maximum number of queued WebRTC sink frames on the receive path. Omit this
   * field to use the default bounded queue size of 1 frame. Set it to 0 to
   * request unbounded buffering.
   *
   * If your application consumes both audio and video, keep the queue sizing
   * strategy coordinated across both streams. Using a much larger queue, or
   * unbounded buffering, for only one of them can increase end-to-end latency
   * for that stream and cause audio/video drift.
   *
   * @generated from field: optional uint32 queue_size_frames = 6;
   */
  queueSizeFrames?: number;

  constructor(data?: PartialMessage<VideoStreamFromParticipantRequest>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoStreamFromParticipantRequest";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.VideoStreamFromParticipantResponse
 */
export declare class VideoStreamFromParticipantResponse extends Message<VideoStreamFromParticipantResponse> {
  /**
   * @generated from field: required livekit.proto.OwnedVideoStream stream = 1;
   */
  stream?: OwnedVideoStream;

  constructor(data?: PartialMessage<VideoStreamFromParticipantResponse>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoStreamFromParticipantResponse";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Create a new VideoSource
 * VideoSource is used to send video frame to a track
 *
 * @generated from message livekit.proto.NewVideoSourceRequest
 */
export declare class NewVideoSourceRequest extends Message<NewVideoSourceRequest> {
  /**
   * @generated from field: required livekit.proto.VideoSourceType type = 1;
   */
  type?: VideoSourceType;

  /**
   * Used to determine which encodings to use + simulcast layers
   * Most of the time it corresponds to the source resolution
   *
   * @generated from field: required livekit.proto.VideoSourceResolution resolution = 2;
   */
  resolution?: VideoSourceResolution;

  /**
   * @generated from field: optional bool is_screencast = 3;
   */
  isScreencast?: boolean;

  constructor(data?: PartialMessage<NewVideoSourceRequest>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.NewVideoSourceRequest";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.NewVideoSourceResponse
 */
export declare class NewVideoSourceResponse extends Message<NewVideoSourceResponse> {
  /**
   * @generated from field: required livekit.proto.OwnedVideoSource source = 1;
   */
  source?: OwnedVideoSource;

  constructor(data?: PartialMessage<NewVideoSourceResponse>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.NewVideoSourceResponse";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Push a frame to a VideoSource
 *
 * @generated from message livekit.proto.CaptureVideoFrameRequest
 */
export declare class CaptureVideoFrameRequest extends Message<CaptureVideoFrameRequest> {
  /**
   * @generated from field: required uint64 source_handle = 1;
   */
  sourceHandle?: bigint;

  /**
   * @generated from field: required livekit.proto.VideoBufferInfo buffer = 2;
   */
  buffer?: VideoBufferInfo;

  /**
   * In microseconds
   *
   * @generated from field: required int64 timestamp_us = 3;
   */
  timestampUs?: bigint;

  /**
   * @generated from field: required livekit.proto.VideoRotation rotation = 4;
   */
  rotation?: VideoRotation;

  /**
   * @generated from field: optional livekit.proto.FrameMetadata metadata = 5;
   */
  metadata?: FrameMetadata;

  constructor(data?: PartialMessage<CaptureVideoFrameRequest>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.CaptureVideoFrameRequest";
  static readonly fields: FieldList;

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

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

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

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

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

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.CaptureVideoFrameResponse";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.VideoConvertRequest
 */
export declare class VideoConvertRequest extends Message<VideoConvertRequest> {
  /**
   * @generated from field: optional bool flip_y = 1;
   */
  flipY?: boolean;

  /**
   * @generated from field: required livekit.proto.VideoBufferInfo buffer = 2;
   */
  buffer?: VideoBufferInfo;

  /**
   * @generated from field: required livekit.proto.VideoBufferType dst_type = 3;
   */
  dstType?: VideoBufferType;

  constructor(data?: PartialMessage<VideoConvertRequest>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoConvertRequest";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.VideoConvertResponse
 */
export declare class VideoConvertResponse extends Message<VideoConvertResponse> {
  /**
   * @generated from oneof livekit.proto.VideoConvertResponse.message
   */
  message: {
    /**
     * @generated from field: string error = 1;
     */
    value: string;
    case: "error";
  } | {
    /**
     * @generated from field: livekit.proto.OwnedVideoBuffer buffer = 2;
     */
    value: OwnedVideoBuffer;
    case: "buffer";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<VideoConvertResponse>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoConvertResponse";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.VideoResolution
 */
export declare class VideoResolution extends Message<VideoResolution> {
  /**
   * @generated from field: required uint32 width = 1;
   */
  width?: number;

  /**
   * @generated from field: required uint32 height = 2;
   */
  height?: number;

  /**
   * @generated from field: required double frame_rate = 3;
   */
  frameRate?: number;

  constructor(data?: PartialMessage<VideoResolution>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoResolution";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.VideoBufferInfo
 */
export declare class VideoBufferInfo extends Message<VideoBufferInfo> {
  /**
   * @generated from field: required livekit.proto.VideoBufferType type = 1;
   */
  type?: VideoBufferType;

  /**
   * @generated from field: required uint32 width = 2;
   */
  width?: number;

  /**
   * @generated from field: required uint32 height = 3;
   */
  height?: number;

  /**
   * @generated from field: required uint64 data_ptr = 4;
   */
  dataPtr?: bigint;

  /**
   * only for packed formats
   *
   * @generated from field: optional uint32 stride = 6;
   */
  stride?: number;

  /**
   * @generated from field: repeated livekit.proto.VideoBufferInfo.ComponentInfo components = 7;
   */
  components: VideoBufferInfo_ComponentInfo[];

  constructor(data?: PartialMessage<VideoBufferInfo>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoBufferInfo";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.VideoBufferInfo.ComponentInfo
 */
export declare class VideoBufferInfo_ComponentInfo extends Message<VideoBufferInfo_ComponentInfo> {
  /**
   * @generated from field: required uint64 data_ptr = 1;
   */
  dataPtr?: bigint;

  /**
   * @generated from field: required uint32 stride = 2;
   */
  stride?: number;

  /**
   * @generated from field: required uint32 size = 3;
   */
  size?: number;

  constructor(data?: PartialMessage<VideoBufferInfo_ComponentInfo>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoBufferInfo.ComponentInfo";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.OwnedVideoBuffer
 */
export declare class OwnedVideoBuffer extends Message<OwnedVideoBuffer> {
  /**
   * @generated from field: required livekit.proto.FfiOwnedHandle handle = 1;
   */
  handle?: FfiOwnedHandle;

  /**
   * @generated from field: required livekit.proto.VideoBufferInfo info = 2;
   */
  info?: VideoBufferInfo;

  constructor(data?: PartialMessage<OwnedVideoBuffer>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.OwnedVideoBuffer";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.FrameMetadata
 */
export declare class FrameMetadata extends Message<FrameMetadata> {
  /**
   * @generated from field: optional uint64 user_timestamp = 1;
   */
  userTimestamp?: bigint;

  /**
   * @generated from field: optional uint32 frame_id = 2;
   */
  frameId?: number;

  /**
   * @generated from field: optional bytes user_data = 3;
   */
  userData?: Uint8Array;

  constructor(data?: PartialMessage<FrameMetadata>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.FrameMetadata";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.VideoStreamInfo
 */
export declare class VideoStreamInfo extends Message<VideoStreamInfo> {
  /**
   * @generated from field: required livekit.proto.VideoStreamType type = 1;
   */
  type?: VideoStreamType;

  constructor(data?: PartialMessage<VideoStreamInfo>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoStreamInfo";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.OwnedVideoStream
 */
export declare class OwnedVideoStream extends Message<OwnedVideoStream> {
  /**
   * @generated from field: required livekit.proto.FfiOwnedHandle handle = 1;
   */
  handle?: FfiOwnedHandle;

  /**
   * @generated from field: required livekit.proto.VideoStreamInfo info = 2;
   */
  info?: VideoStreamInfo;

  constructor(data?: PartialMessage<OwnedVideoStream>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.OwnedVideoStream";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.VideoStreamEvent
 */
export declare class VideoStreamEvent extends Message<VideoStreamEvent> {
  /**
   * @generated from field: required uint64 stream_handle = 1;
   */
  streamHandle?: bigint;

  /**
   * @generated from oneof livekit.proto.VideoStreamEvent.message
   */
  message: {
    /**
     * @generated from field: livekit.proto.VideoFrameReceived frame_received = 2;
     */
    value: VideoFrameReceived;
    case: "frameReceived";
  } | {
    /**
     * @generated from field: livekit.proto.VideoStreamEOS eos = 3;
     */
    value: VideoStreamEOS;
    case: "eos";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<VideoStreamEvent>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoStreamEvent";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.VideoFrameReceived
 */
export declare class VideoFrameReceived extends Message<VideoFrameReceived> {
  /**
   * @generated from field: required livekit.proto.OwnedVideoBuffer buffer = 1;
   */
  buffer?: OwnedVideoBuffer;

  /**
   * In microseconds
   *
   * @generated from field: required int64 timestamp_us = 2;
   */
  timestampUs?: bigint;

  /**
   * @generated from field: required livekit.proto.VideoRotation rotation = 3;
   */
  rotation?: VideoRotation;

  /**
   * @generated from field: optional livekit.proto.FrameMetadata metadata = 4;
   */
  metadata?: FrameMetadata;

  constructor(data?: PartialMessage<VideoFrameReceived>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoFrameReceived";
  static readonly fields: FieldList;

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

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

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

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

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

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoStreamEOS";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.VideoSourceResolution
 */
export declare class VideoSourceResolution extends Message<VideoSourceResolution> {
  /**
   * @generated from field: required uint32 width = 1;
   */
  width?: number;

  /**
   * @generated from field: required uint32 height = 2;
   */
  height?: number;

  constructor(data?: PartialMessage<VideoSourceResolution>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoSourceResolution";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.VideoSourceInfo
 */
export declare class VideoSourceInfo extends Message<VideoSourceInfo> {
  /**
   * @generated from field: required livekit.proto.VideoSourceType type = 1;
   */
  type?: VideoSourceType;

  constructor(data?: PartialMessage<VideoSourceInfo>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.VideoSourceInfo";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message livekit.proto.OwnedVideoSource
 */
export declare class OwnedVideoSource extends Message<OwnedVideoSource> {
  /**
   * @generated from field: required livekit.proto.FfiOwnedHandle handle = 1;
   */
  handle?: FfiOwnedHandle;

  /**
   * @generated from field: required livekit.proto.VideoSourceInfo info = 2;
   */
  info?: VideoSourceInfo;

  constructor(data?: PartialMessage<OwnedVideoSource>);

  static readonly runtime: typeof proto2;
  static readonly typeName = "livekit.proto.OwnedVideoSource";
  static readonly fields: FieldList;

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

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

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

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