// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.7.5
//   protoc               v5.28.0
// source: video_streaming/streamer_context.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";

export const protobufPackage = "video_streaming";

export interface StreamerContext {
  clientInfo?: StreamerContext_ClientInfo | undefined;
  poToken?: Uint8Array | undefined;
  playbackCookie?: Uint8Array | undefined;
  field4?: Uint8Array | undefined;
  sabrContexts: StreamerContext_SabrContext[];
  unsentSabrContexts: number[];
  field7?: string | undefined;
  field8?: StreamerContext_UnknownMessage1 | undefined;
}

export enum StreamerContext_ClientFormFactor {
  UNKNOWN_FORM_FACTOR = 0,
  FORM_FACTOR_VAL1 = 1,
  FORM_FACTOR_VAL2 = 2,
  UNRECOGNIZED = -1,
}

export interface StreamerContext_ClientInfo {
  deviceMake?: string | undefined;
  deviceModel?: string | undefined;
  clientName?: number | undefined;
  clientVersion?: string | undefined;
  osName?: string | undefined;
  osVersion?: string | undefined;
  acceptLanguage?: string | undefined;
  acceptRegion?: string | undefined;
  screenWidthPoints?: number | undefined;
  screenHeightPoints?: number | undefined;
  screenWidthInches?: number | undefined;
  screenHeightInches?: number | undefined;
  screenPixelDensity?: number | undefined;
  clientFormFactor?:
    | StreamerContext_ClientFormFactor
    | undefined;
  /** e.g. 243731017 */
  gmscoreVersionCode?: number | undefined;
  windowWidthPoints?: number | undefined;
  windowHeightPoints?: number | undefined;
  androidSdkVersion?: number | undefined;
  screenDensityFloat?: number | undefined;
  utcOffsetMinutes?: string | undefined;
  timeZone?:
    | string
    | undefined;
  /** e.g. "qcom;taro" */
  chipset?: string | undefined;
  glDeviceInfo?: StreamerContext_GLDeviceInfo | undefined;
}

export interface StreamerContext_GLDeviceInfo {
  glRenderer?: string | undefined;
  glEsVersionMajor?: number | undefined;
  glEsVersionMinor?: number | undefined;
}

export interface StreamerContext_SabrContext {
  type?: number | undefined;
  value?: Uint8Array | undefined;
}

export interface StreamerContext_UnknownMessage1 {
  field1?: Uint8Array | undefined;
  field2?: StreamerContext_UnknownMessage1_UnknownInnerMessage1 | undefined;
}

export interface StreamerContext_UnknownMessage1_UnknownInnerMessage1 {
  code?: number | undefined;
  message?: string | undefined;
}

function createBaseStreamerContext(): StreamerContext {
  return {
    clientInfo: undefined,
    poToken: new Uint8Array(0),
    playbackCookie: new Uint8Array(0),
    field4: new Uint8Array(0),
    sabrContexts: [],
    unsentSabrContexts: [],
    field7: "",
    field8: undefined,
  };
}

export const StreamerContext: MessageFns<StreamerContext> = {
  encode(message: StreamerContext, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.clientInfo !== undefined) {
      StreamerContext_ClientInfo.encode(message.clientInfo, writer.uint32(10).fork()).join();
    }
    if (message.poToken !== undefined && message.poToken.length !== 0) {
      writer.uint32(18).bytes(message.poToken);
    }
    if (message.playbackCookie !== undefined && message.playbackCookie.length !== 0) {
      writer.uint32(26).bytes(message.playbackCookie);
    }
    if (message.field4 !== undefined && message.field4.length !== 0) {
      writer.uint32(34).bytes(message.field4);
    }
    for (const v of message.sabrContexts) {
      StreamerContext_SabrContext.encode(v!, writer.uint32(42).fork()).join();
    }
    writer.uint32(50).fork();
    for (const v of message.unsentSabrContexts) {
      writer.int32(v);
    }
    writer.join();
    if (message.field7 !== undefined && message.field7 !== "") {
      writer.uint32(58).string(message.field7);
    }
    if (message.field8 !== undefined) {
      StreamerContext_UnknownMessage1.encode(message.field8, writer.uint32(66).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): StreamerContext {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseStreamerContext();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.clientInfo = StreamerContext_ClientInfo.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.poToken = reader.bytes();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.playbackCookie = reader.bytes();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.field4 = reader.bytes();
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }

          message.sabrContexts.push(StreamerContext_SabrContext.decode(reader, reader.uint32()));
          continue;
        }
        case 6: {
          if (tag === 48) {
            message.unsentSabrContexts.push(reader.int32());

            continue;
          }

          if (tag === 50) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.unsentSabrContexts.push(reader.int32());
            }

            continue;
          }

          break;
        }
        case 7: {
          if (tag !== 58) {
            break;
          }

          message.field7 = reader.string();
          continue;
        }
        case 8: {
          if (tag !== 66) {
            break;
          }

          message.field8 = StreamerContext_UnknownMessage1.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseStreamerContext_ClientInfo(): StreamerContext_ClientInfo {
  return {
    deviceMake: "",
    deviceModel: "",
    clientName: 0,
    clientVersion: "",
    osName: "",
    osVersion: "",
    acceptLanguage: "",
    acceptRegion: "",
    screenWidthPoints: 0,
    screenHeightPoints: 0,
    screenWidthInches: 0,
    screenHeightInches: 0,
    screenPixelDensity: 0,
    clientFormFactor: 0,
    gmscoreVersionCode: 0,
    windowWidthPoints: 0,
    windowHeightPoints: 0,
    androidSdkVersion: 0,
    screenDensityFloat: 0,
    utcOffsetMinutes: "0",
    timeZone: "",
    chipset: "",
    glDeviceInfo: undefined,
  };
}

export const StreamerContext_ClientInfo: MessageFns<StreamerContext_ClientInfo> = {
  encode(message: StreamerContext_ClientInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.deviceMake !== undefined && message.deviceMake !== "") {
      writer.uint32(98).string(message.deviceMake);
    }
    if (message.deviceModel !== undefined && message.deviceModel !== "") {
      writer.uint32(106).string(message.deviceModel);
    }
    if (message.clientName !== undefined && message.clientName !== 0) {
      writer.uint32(128).int32(message.clientName);
    }
    if (message.clientVersion !== undefined && message.clientVersion !== "") {
      writer.uint32(138).string(message.clientVersion);
    }
    if (message.osName !== undefined && message.osName !== "") {
      writer.uint32(146).string(message.osName);
    }
    if (message.osVersion !== undefined && message.osVersion !== "") {
      writer.uint32(154).string(message.osVersion);
    }
    if (message.acceptLanguage !== undefined && message.acceptLanguage !== "") {
      writer.uint32(170).string(message.acceptLanguage);
    }
    if (message.acceptRegion !== undefined && message.acceptRegion !== "") {
      writer.uint32(178).string(message.acceptRegion);
    }
    if (message.screenWidthPoints !== undefined && message.screenWidthPoints !== 0) {
      writer.uint32(296).int32(message.screenWidthPoints);
    }
    if (message.screenHeightPoints !== undefined && message.screenHeightPoints !== 0) {
      writer.uint32(304).int32(message.screenHeightPoints);
    }
    if (message.screenWidthInches !== undefined && message.screenWidthInches !== 0) {
      writer.uint32(317).float(message.screenWidthInches);
    }
    if (message.screenHeightInches !== undefined && message.screenHeightInches !== 0) {
      writer.uint32(325).float(message.screenHeightInches);
    }
    if (message.screenPixelDensity !== undefined && message.screenPixelDensity !== 0) {
      writer.uint32(328).int32(message.screenPixelDensity);
    }
    if (message.clientFormFactor !== undefined && message.clientFormFactor !== 0) {
      writer.uint32(368).int32(message.clientFormFactor);
    }
    if (message.gmscoreVersionCode !== undefined && message.gmscoreVersionCode !== 0) {
      writer.uint32(400).int32(message.gmscoreVersionCode);
    }
    if (message.windowWidthPoints !== undefined && message.windowWidthPoints !== 0) {
      writer.uint32(440).int32(message.windowWidthPoints);
    }
    if (message.windowHeightPoints !== undefined && message.windowHeightPoints !== 0) {
      writer.uint32(448).int32(message.windowHeightPoints);
    }
    if (message.androidSdkVersion !== undefined && message.androidSdkVersion !== 0) {
      writer.uint32(512).int32(message.androidSdkVersion);
    }
    if (message.screenDensityFloat !== undefined && message.screenDensityFloat !== 0) {
      writer.uint32(525).float(message.screenDensityFloat);
    }
    if (message.utcOffsetMinutes !== undefined && message.utcOffsetMinutes !== "0") {
      writer.uint32(536).int64(message.utcOffsetMinutes);
    }
    if (message.timeZone !== undefined && message.timeZone !== "") {
      writer.uint32(642).string(message.timeZone);
    }
    if (message.chipset !== undefined && message.chipset !== "") {
      writer.uint32(738).string(message.chipset);
    }
    if (message.glDeviceInfo !== undefined) {
      StreamerContext_GLDeviceInfo.encode(message.glDeviceInfo, writer.uint32(818).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): StreamerContext_ClientInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseStreamerContext_ClientInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 12: {
          if (tag !== 98) {
            break;
          }

          message.deviceMake = reader.string();
          continue;
        }
        case 13: {
          if (tag !== 106) {
            break;
          }

          message.deviceModel = reader.string();
          continue;
        }
        case 16: {
          if (tag !== 128) {
            break;
          }

          message.clientName = reader.int32();
          continue;
        }
        case 17: {
          if (tag !== 138) {
            break;
          }

          message.clientVersion = reader.string();
          continue;
        }
        case 18: {
          if (tag !== 146) {
            break;
          }

          message.osName = reader.string();
          continue;
        }
        case 19: {
          if (tag !== 154) {
            break;
          }

          message.osVersion = reader.string();
          continue;
        }
        case 21: {
          if (tag !== 170) {
            break;
          }

          message.acceptLanguage = reader.string();
          continue;
        }
        case 22: {
          if (tag !== 178) {
            break;
          }

          message.acceptRegion = reader.string();
          continue;
        }
        case 37: {
          if (tag !== 296) {
            break;
          }

          message.screenWidthPoints = reader.int32();
          continue;
        }
        case 38: {
          if (tag !== 304) {
            break;
          }

          message.screenHeightPoints = reader.int32();
          continue;
        }
        case 39: {
          if (tag !== 317) {
            break;
          }

          message.screenWidthInches = reader.float();
          continue;
        }
        case 40: {
          if (tag !== 325) {
            break;
          }

          message.screenHeightInches = reader.float();
          continue;
        }
        case 41: {
          if (tag !== 328) {
            break;
          }

          message.screenPixelDensity = reader.int32();
          continue;
        }
        case 46: {
          if (tag !== 368) {
            break;
          }

          message.clientFormFactor = reader.int32() as any;
          continue;
        }
        case 50: {
          if (tag !== 400) {
            break;
          }

          message.gmscoreVersionCode = reader.int32();
          continue;
        }
        case 55: {
          if (tag !== 440) {
            break;
          }

          message.windowWidthPoints = reader.int32();
          continue;
        }
        case 56: {
          if (tag !== 448) {
            break;
          }

          message.windowHeightPoints = reader.int32();
          continue;
        }
        case 64: {
          if (tag !== 512) {
            break;
          }

          message.androidSdkVersion = reader.int32();
          continue;
        }
        case 65: {
          if (tag !== 525) {
            break;
          }

          message.screenDensityFloat = reader.float();
          continue;
        }
        case 67: {
          if (tag !== 536) {
            break;
          }

          message.utcOffsetMinutes = reader.int64().toString();
          continue;
        }
        case 80: {
          if (tag !== 642) {
            break;
          }

          message.timeZone = reader.string();
          continue;
        }
        case 92: {
          if (tag !== 738) {
            break;
          }

          message.chipset = reader.string();
          continue;
        }
        case 102: {
          if (tag !== 818) {
            break;
          }

          message.glDeviceInfo = StreamerContext_GLDeviceInfo.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseStreamerContext_GLDeviceInfo(): StreamerContext_GLDeviceInfo {
  return { glRenderer: "", glEsVersionMajor: 0, glEsVersionMinor: 0 };
}

export const StreamerContext_GLDeviceInfo: MessageFns<StreamerContext_GLDeviceInfo> = {
  encode(message: StreamerContext_GLDeviceInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.glRenderer !== undefined && message.glRenderer !== "") {
      writer.uint32(10).string(message.glRenderer);
    }
    if (message.glEsVersionMajor !== undefined && message.glEsVersionMajor !== 0) {
      writer.uint32(16).int32(message.glEsVersionMajor);
    }
    if (message.glEsVersionMinor !== undefined && message.glEsVersionMinor !== 0) {
      writer.uint32(24).int32(message.glEsVersionMinor);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): StreamerContext_GLDeviceInfo {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseStreamerContext_GLDeviceInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.glRenderer = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.glEsVersionMajor = reader.int32();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.glEsVersionMinor = reader.int32();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseStreamerContext_SabrContext(): StreamerContext_SabrContext {
  return { type: 0, value: new Uint8Array(0) };
}

export const StreamerContext_SabrContext: MessageFns<StreamerContext_SabrContext> = {
  encode(message: StreamerContext_SabrContext, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.type !== undefined && message.type !== 0) {
      writer.uint32(8).int32(message.type);
    }
    if (message.value !== undefined && message.value.length !== 0) {
      writer.uint32(18).bytes(message.value);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): StreamerContext_SabrContext {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseStreamerContext_SabrContext();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.type = reader.int32();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.value = reader.bytes();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseStreamerContext_UnknownMessage1(): StreamerContext_UnknownMessage1 {
  return { field1: new Uint8Array(0), field2: undefined };
}

export const StreamerContext_UnknownMessage1: MessageFns<StreamerContext_UnknownMessage1> = {
  encode(message: StreamerContext_UnknownMessage1, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.field1 !== undefined && message.field1.length !== 0) {
      writer.uint32(10).bytes(message.field1);
    }
    if (message.field2 !== undefined) {
      StreamerContext_UnknownMessage1_UnknownInnerMessage1.encode(message.field2, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): StreamerContext_UnknownMessage1 {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseStreamerContext_UnknownMessage1();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.field1 = reader.bytes();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.field2 = StreamerContext_UnknownMessage1_UnknownInnerMessage1.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseStreamerContext_UnknownMessage1_UnknownInnerMessage1(): StreamerContext_UnknownMessage1_UnknownInnerMessage1 {
  return { code: 0, message: "" };
}

export const StreamerContext_UnknownMessage1_UnknownInnerMessage1: MessageFns<
  StreamerContext_UnknownMessage1_UnknownInnerMessage1
> = {
  encode(
    message: StreamerContext_UnknownMessage1_UnknownInnerMessage1,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.code !== undefined && message.code !== 0) {
      writer.uint32(8).int32(message.code);
    }
    if (message.message !== undefined && message.message !== "") {
      writer.uint32(18).string(message.message);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): StreamerContext_UnknownMessage1_UnknownInnerMessage1 {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseStreamerContext_UnknownMessage1_UnknownInnerMessage1();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.code = reader.int32();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.message = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

export interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
}