// Code generated by protoc-gen-grpc-ts. DO NOT EDIT.
// Generated from: object/types.proto

import { NeoFsV2Refs } from '../refs/types_pb';
import { NeoFsV2Session } from '../session/types_pb';

type ChecksumType = NeoFsV2Refs.ChecksumType;

class BinaryWriter {
  private buffer: Uint8Array = new Uint8Array(1024);
  private position: number = 0;

  private ensureCapacity(needed: number): void {
    if (this.position + needed > this.buffer.length) {
      const minSize = this.position + needed
      const newBuffer = new Uint8Array(Math.max(this.buffer.length * 2, minSize))
      newBuffer.set(this.buffer);
      this.buffer = newBuffer;
    }
  }

  private writeVarint(value: number): void {
    while (value > 127) {
      this.ensureCapacity(1);
      this.buffer[this.position++] = (value & 127) | 128;
      value >>>= 7;
    }
    this.ensureCapacity(1);
    this.buffer[this.position++] = value & 127;
  }

  private writeVarintBigInt(value: bigint): void {
    while (value > 127n) {
      this.ensureCapacity(1);
      this.buffer[this.position++] = Number(value & 127n) | 128;
      value >>= 7n;
    }
    this.ensureCapacity(1);
    this.buffer[this.position++] = Number(value & 127n);
  }

  writeDouble(fieldNumber: number, value: number): void {
    this.writeVarint((fieldNumber << 3) | 1); // wire type 1
    this.ensureCapacity(8);
    const view = new DataView(this.buffer.buffer, this.buffer.byteOffset + this.position, 8);
    view.setFloat64(0, value, true); // little endian
    this.position += 8;
  }

  writeFloat(fieldNumber: number, value: number): void {
    this.writeVarint((fieldNumber << 3) | 5); // wire type 5
    this.ensureCapacity(4);
    const view = new DataView(this.buffer.buffer, this.buffer.byteOffset + this.position, 4);
    view.setFloat32(0, value, true); // little endian
    this.position += 4;
  }

  writeInt32(fieldNumber: number, value: number): void {
    this.writeVarint((fieldNumber << 3) | 0); // wire type 0
    this.writeVarint(value);
  }

  writeInt64(fieldNumber: number, value: bigint): void {
    this.writeVarint((fieldNumber << 3) | 0); // wire type 0
    this.writeVarintBigInt(value);
  }

  writeUint32(fieldNumber: number, value: number): void {
    this.writeVarint((fieldNumber << 3) | 0); // wire type 0
    this.writeVarint(value);
  }

  writeUint64(fieldNumber: number, value: bigint): void {
    this.writeVarint((fieldNumber << 3) | 0); // wire type 0
    this.writeVarintBigInt(value);
  }

  writeBool(fieldNumber: number, value: boolean): void {
    this.writeVarint((fieldNumber << 3) | 0); // wire type 0
    this.writeVarint(value ? 1 : 0);
  }

  writeString(fieldNumber: number, value: string): void {
    this.writeVarint((fieldNumber << 3) | 2); // wire type 2
    const bytes = this.encodeString(value);
    this.writeVarint(bytes.length);
    this.ensureCapacity(bytes.length);
    this.buffer.set(bytes, this.position);
    this.position += bytes.length;
  }

  writeBytes(fieldNumber: number, value: Uint8Array): void {
    this.writeVarint((fieldNumber << 3) | 2); // wire type 2
    this.writeVarint(value.length);
    this.ensureCapacity(value.length);
    this.buffer.set(value, this.position);
    this.position += value.length;
  }

  writeMessage(fieldNumber: number, value: any): void {
    this.writeVarint((fieldNumber << 3) | 2); // wire type 2
    const bytes = value.serializeBinary();
    this.writeVarint(bytes.length);
    this.ensureCapacity(bytes.length);
    this.buffer.set(bytes, this.position);
    this.position += bytes.length;
  }

  writeEnum(fieldNumber: number, value: number): void {
    this.writeVarint((fieldNumber << 3) | 0); // wire type 0
    this.writeVarint(value);
  }

  private encodeString(str: string): Uint8Array {
    // Manual UTF-8 encoding (React Native compatible)
    const bytes: number[] = [];
    for (let i = 0; i < str.length; i++) {
      let codePoint = str.charCodeAt(i);
      if (codePoint >= 0xD800 && codePoint <= 0xDBFF && i + 1 < str.length) {
        const next = str.charCodeAt(i + 1);
        if (next >= 0xDC00 && next <= 0xDFFF) {
          codePoint = 0x10000 + ((codePoint - 0xD800) << 10) + (next - 0xDC00);
          i++;
        }
      }
      if (codePoint < 0x80) {
        bytes.push(codePoint);
      } else if (codePoint < 0x800) {
        bytes.push(0xC0 | (codePoint >> 6), 0x80 | (codePoint & 0x3F));
      } else if (codePoint < 0x10000) {
        bytes.push(0xE0 | (codePoint >> 12), 0x80 | ((codePoint >> 6) & 0x3F), 0x80 | (codePoint & 0x3F));
      } else {
        bytes.push(0xF0 | (codePoint >> 18), 0x80 | ((codePoint >> 12) & 0x3F), 0x80 | ((codePoint >> 6) & 0x3F), 0x80 | (codePoint & 0x3F));
      }
    }
    return new Uint8Array(bytes);
  }

  getResultBuffer(): Uint8Array {
    return this.buffer.slice(0, this.position);
  }
}

class BinaryReader {
  buffer: Uint8Array;
  position: number = 0;

  constructor(data: Uint8Array) {
    this.buffer = data;
  }

  readVarint(): number {
    let result = 0;
    let shift = 0;
    while (this.position < this.buffer.length) {
      const byte = this.buffer[this.position++];
      result |= (byte & 127) << shift;
      if ((byte & 128) === 0) break;
      shift += 7;
    }
    return result;
  }

  readVarintBigInt(): bigint {
    let result = 0n;
    let shift = 0n;
    while (this.position < this.buffer.length) {
      const byte = BigInt(this.buffer[this.position++]);
      result |= (byte & 127n) << shift;
      if ((byte & 128n) === 0n) break;
      shift += 7n;
    }
    return result;
  }

  readDouble(): number {
    const view = new DataView(this.buffer.buffer, this.buffer.byteOffset + this.position, 8);
    this.position += 8;
    return view.getFloat64(0, true); // little endian
  }

  readFloat(): number {
    const view = new DataView(this.buffer.buffer, this.buffer.byteOffset + this.position, 4);
    this.position += 4;
    return view.getFloat32(0, true); // little endian
  }

  readInt32(): number {
    return this.readVarint();
  }

  readInt64(): bigint {
    return this.readVarintBigInt();
  }

  readUint32(): number {
    return this.readVarint();
  }

  readUint64(): bigint {
    return this.readVarintBigInt();
  }

  readBool(): boolean {
    return this.readVarint() !== 0;
  }

  readString(): string {
    const length = this.readVarint();
    const bytes = this.buffer.slice(this.position, this.position + length);
    this.position += length;
    return this.decodeString(bytes);
  }

  private decodeString(bytes: Uint8Array): string {
    // Manual UTF-8 decoding (React Native compatible)
    let result = '';
    let i = 0;
    while (i < bytes.length) {
      const byte1 = bytes[i++];
      if (byte1 < 0x80) {
        result += String.fromCharCode(byte1);
      } else if ((byte1 & 0xE0) === 0xC0) {
        const byte2 = bytes[i++] & 0x3F;
        result += String.fromCharCode(((byte1 & 0x1F) << 6) | byte2);
      } else if ((byte1 & 0xF0) === 0xE0) {
        const byte2 = bytes[i++] & 0x3F;
        const byte3 = bytes[i++] & 0x3F;
        result += String.fromCharCode(((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3);
      } else if ((byte1 & 0xF8) === 0xF0) {
        const byte2 = bytes[i++] & 0x3F;
        const byte3 = bytes[i++] & 0x3F;
        const byte4 = bytes[i++] & 0x3F;
        const codePoint = ((byte1 & 0x07) << 18) | (byte2 << 12) | (byte3 << 6) | byte4;
        result += String.fromCharCode(0xD800 + ((codePoint - 0x10000) >> 10), 0xDC00 + ((codePoint - 0x10000) & 0x3FF));
      }
    }
    return result;
  }

  readBytes(): Uint8Array {
    const length = this.readVarint();
    const bytes = this.buffer.slice(this.position, this.position + length);
    this.position += length;
    return bytes;
  }

  readMessage<T>(deserialize: (data: Uint8Array) => T): T {
    const length = this.readVarint();
    const bytes = this.buffer.slice(this.position, this.position + length);
    this.position += length;
    return deserialize(bytes);
  }

  readEnum(): number {
    return this.readVarint();
  }

  readInt32Fixed(): number {
    const bytes = this.buffer.slice(this.position, this.position + 4);
    this.position += 4;
    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
    return view.getInt32(0, true); // little-endian
  }

  readInt64Fixed(): bigint {
    const bytes = this.buffer.slice(this.position, this.position + 8);
    this.position += 8;
    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
    return view.getBigInt64(0, true); // little-endian
  }

  readUint32Fixed(): number {
    const bytes = this.buffer.slice(this.position, this.position + 4);
    this.position += 4;
    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
    return view.getUint32(0, true); // little-endian
  }

  readUint64Fixed(): bigint {
    const bytes = this.buffer.slice(this.position, this.position + 8);
    this.position += 8;
    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
    return view.getBigUint64(0, true); // little-endian
  }

  skipField(wireType: number): void {
    switch (wireType) {
      case 0: // Varint
        this.readVarint();
        break;
      case 1: // 64-bit
        this.position += 8;
        break;
      case 2: // Length-delimited
        const length = this.readVarint();
        this.position += length;
        break;
      case 3: // Start group (deprecated, just skip)
        // Groups are deprecated in proto3, skip without reading
        break;
      case 4: // End group (deprecated, just skip)
        // Groups are deprecated in proto3, skip without reading
        break;
      case 5: // 32-bit
        this.position += 4;
        break;
      default:
        throw new Error(`Unknown wire type: ${wireType}`);
    }
  }
}

export namespace NeoFsV2Object {

export enum ObjectType {
  ObjectType_REGULAR = 0,
  ObjectType_TOMBSTONE = 1,
  ObjectType_STORAGE_GROUP = 2,
  ObjectType_LOCK = 3,
  ObjectType_LINK = 4,
}

export enum MatchType {
  MatchType_MATCH_TYPE_UNSPECIFIED = 0,
  MatchType_STRING_EQUAL = 1,
  MatchType_STRING_NOT_EQUAL = 2,
  MatchType_NOT_PRESENT = 3,
  MatchType_COMMON_PREFIX = 4,
  MatchType_NUM_GT = 5,
  MatchType_NUM_GE = 6,
  MatchType_NUM_LT = 7,
  MatchType_NUM_LE = 8,
}

export interface SearchFilter {
  MatchType: MatchType;
  Key: string;
  Value: string;
}

export class SearchFilterImpl implements SearchFilter {
  MatchType!: MatchType;
  Key!: string;
  Value!: string;

  constructor(data?: Partial<SearchFilter>) {
    this.MatchType = data?.MatchType ?? 0;
    this.Key = data?.Key ?? "";
    this.Value = data?.Value ?? "";
  }

  serializeBinary(): Uint8Array {
    const writer = new BinaryWriter();

    if (this.MatchType !== 0) {
      writer.writeEnum(1, this.MatchType);
    }
    if (this.Key !== "") {
      writer.writeString(2, this.Key);
    }
    if (this.Value !== "") {
      writer.writeString(3, this.Value);
    }
    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): SearchFilterImpl {
    const reader = new BinaryReader(data);
    const message = new SearchFilterImpl();

    // Parse protobuf wire format
    while (reader.position < reader.buffer.length) {
      const tag = reader.readVarint();
      const fieldNumber = tag >>> 3;
      const wireType = tag & 7;

      switch (fieldNumber) {
        case 1: // MatchType
          if (wireType === 0) { // Varint
            message.MatchType = reader.readEnum();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Key
          if (wireType === 2) { // Length-delimited
            message.Key = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Value
          if (wireType === 2) { // Length-delimited
            message.Value = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SearchFilterData {
    return {
      MatchType: this.MatchType,
      Key: this.Key,
      Value: this.Value
    };
  }

}

// Export class alias without Impl suffix for Node.js compatibility
export class SearchFilter extends SearchFilterImpl {}

// Type for interface data only (excludes class methods from merged type)
export type SearchFilterData = Omit<SearchFilter, 'serializeBinary' | 'toObject' | 'constructor'>;

export interface ShortHeader {
  Version?: NeoFsV2Refs.Version;
  CreationEpoch: bigint;
  OwnerId?: NeoFsV2Refs.OwnerID;
  ObjectType: ObjectType;
  PayloadLength: bigint;
  PayloadHash?: NeoFsV2Refs.Checksum;
  HomomorphicHash?: NeoFsV2Refs.Checksum;
}

export class ShortHeaderImpl implements ShortHeader {
  Version?: NeoFsV2Refs.Version;
  CreationEpoch!: bigint;
  OwnerId?: NeoFsV2Refs.OwnerID;
  ObjectType!: ObjectType;
  PayloadLength!: bigint;
  PayloadHash?: NeoFsV2Refs.Checksum;
  HomomorphicHash?: NeoFsV2Refs.Checksum;

  constructor(data?: Partial<ShortHeader>) {
    this.Version = data?.Version ?? undefined;
    this.CreationEpoch = data?.CreationEpoch ?? 0n;
    this.OwnerId = data?.OwnerId ?? undefined;
    this.ObjectType = data?.ObjectType ?? 0;
    this.PayloadLength = data?.PayloadLength ?? 0n;
    this.PayloadHash = data?.PayloadHash ?? undefined;
    this.HomomorphicHash = data?.HomomorphicHash ?? undefined;
  }

  serializeBinary(): Uint8Array {
    const writer = new BinaryWriter();

    if (this.Version) {
      writer.writeMessage(1, this.Version);
    }
    if (this.CreationEpoch !== 0n) {
      writer.writeUint64(2, this.CreationEpoch);
    }
    if (this.OwnerId) {
      writer.writeMessage(3, this.OwnerId);
    }
    if (this.ObjectType !== 0) {
      writer.writeEnum(4, this.ObjectType);
    }
    if (this.PayloadLength !== 0n) {
      writer.writeUint64(5, this.PayloadLength);
    }
    if (this.PayloadHash) {
      writer.writeMessage(6, this.PayloadHash);
    }
    if (this.HomomorphicHash) {
      writer.writeMessage(7, this.HomomorphicHash);
    }
    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): ShortHeaderImpl {
    const reader = new BinaryReader(data);
    const message = new ShortHeaderImpl();

    // Parse protobuf wire format
    while (reader.position < reader.buffer.length) {
      const tag = reader.readVarint();
      const fieldNumber = tag >>> 3;
      const wireType = tag & 7;

      switch (fieldNumber) {
        case 1: // Version
          if (wireType === 2) { // Length-delimited
            message.Version = reader.readMessage(NeoFsV2Refs.VersionImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // CreationEpoch
          if (wireType === 0) { // Varint
            message.CreationEpoch = reader.readUint64();
          } else if (wireType === 1) { // 64-bit
            message.CreationEpoch = reader.readUint64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // OwnerId
          if (wireType === 2) { // Length-delimited
            message.OwnerId = reader.readMessage(NeoFsV2Refs.OwnerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // ObjectType
          if (wireType === 0) { // Varint
            message.ObjectType = reader.readEnum();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 5: // PayloadLength
          if (wireType === 0) { // Varint
            message.PayloadLength = reader.readUint64();
          } else if (wireType === 1) { // 64-bit
            message.PayloadLength = reader.readUint64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 6: // PayloadHash
          if (wireType === 2) { // Length-delimited
            message.PayloadHash = reader.readMessage(NeoFsV2Refs.ChecksumImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 7: // HomomorphicHash
          if (wireType === 2) { // Length-delimited
            message.HomomorphicHash = reader.readMessage(NeoFsV2Refs.ChecksumImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): ShortHeaderData {
    return {
      Version: this.Version,
      CreationEpoch: this.CreationEpoch,
      OwnerId: this.OwnerId,
      ObjectType: this.ObjectType,
      PayloadLength: this.PayloadLength,
      PayloadHash: this.PayloadHash,
      HomomorphicHash: this.HomomorphicHash
    };
  }

}

// Export class alias without Impl suffix for Node.js compatibility
export class ShortHeader extends ShortHeaderImpl {}

// Type for interface data only (excludes class methods from merged type)
export type ShortHeaderData = Omit<ShortHeader, 'serializeBinary' | 'toObject' | 'constructor'>;

export interface Header {
  Version?: NeoFsV2Refs.Version;
  ContainerId?: NeoFsV2Refs.ContainerID;
  OwnerId?: NeoFsV2Refs.OwnerID;
  CreationEpoch: bigint;
  PayloadLength: bigint;
  PayloadHash?: NeoFsV2Refs.Checksum;
  ObjectType: ObjectType;
  HomomorphicHash?: NeoFsV2Refs.Checksum;
  SessionToken?: NeoFsV2Session.SessionToken;
  Attributes: Header_Attribute[];
  Split?: Header_Split;
  SessionTokenV2?: NeoFsV2Session.SessionTokenV2;
}

export class HeaderImpl implements Header {
  Version?: NeoFsV2Refs.Version;
  ContainerId?: NeoFsV2Refs.ContainerID;
  OwnerId?: NeoFsV2Refs.OwnerID;
  CreationEpoch!: bigint;
  PayloadLength!: bigint;
  PayloadHash?: NeoFsV2Refs.Checksum;
  ObjectType!: ObjectType;
  HomomorphicHash?: NeoFsV2Refs.Checksum;
  SessionToken?: NeoFsV2Session.SessionToken;
  Attributes!: Header_Attribute[];
  Split?: Header_Split;
  SessionTokenV2?: NeoFsV2Session.SessionTokenV2;

  constructor(data?: Partial<Header>) {
    this.Version = data?.Version ?? undefined;
    this.ContainerId = data?.ContainerId ?? undefined;
    this.OwnerId = data?.OwnerId ?? undefined;
    this.CreationEpoch = data?.CreationEpoch ?? 0n;
    this.PayloadLength = data?.PayloadLength ?? 0n;
    this.PayloadHash = data?.PayloadHash ?? undefined;
    this.ObjectType = data?.ObjectType ?? 0;
    this.HomomorphicHash = data?.HomomorphicHash ?? undefined;
    this.SessionToken = data?.SessionToken ?? undefined;
    this.Attributes = data?.Attributes ?? [];
    this.Split = data?.Split ?? undefined;
    this.SessionTokenV2 = data?.SessionTokenV2 ?? undefined;
  }

  serializeBinary(): Uint8Array {
    const writer = new BinaryWriter();

    if (this.Version) {
      writer.writeMessage(1, this.Version);
    }
    if (this.ContainerId) {
      writer.writeMessage(2, this.ContainerId);
    }
    if (this.OwnerId) {
      writer.writeMessage(3, this.OwnerId);
    }
    if (this.CreationEpoch !== 0n) {
      writer.writeUint64(4, this.CreationEpoch);
    }
    if (this.PayloadLength !== 0n) {
      writer.writeUint64(5, this.PayloadLength);
    }
    if (this.PayloadHash) {
      writer.writeMessage(6, this.PayloadHash);
    }
    if (this.ObjectType !== 0) {
      writer.writeEnum(7, this.ObjectType);
    }
    if (this.HomomorphicHash) {
      writer.writeMessage(8, this.HomomorphicHash);
    }
    if (this.SessionToken) {
      writer.writeMessage(9, this.SessionToken);
    }
    for (const item of this.Attributes) {
      writer.writeMessage(10, item);
    }
    if (this.Split) {
      writer.writeMessage(11, this.Split);
    }
    if (this.SessionTokenV2) {
      writer.writeMessage(12, this.SessionTokenV2);
    }
    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): HeaderImpl {
    const reader = new BinaryReader(data);
    const message = new HeaderImpl();

    // Parse protobuf wire format
    while (reader.position < reader.buffer.length) {
      const tag = reader.readVarint();
      const fieldNumber = tag >>> 3;
      const wireType = tag & 7;

      switch (fieldNumber) {
        case 1: // Version
          if (wireType === 2) { // Length-delimited
            message.Version = reader.readMessage(NeoFsV2Refs.VersionImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // ContainerId
          if (wireType === 2) { // Length-delimited
            message.ContainerId = reader.readMessage(NeoFsV2Refs.ContainerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // OwnerId
          if (wireType === 2) { // Length-delimited
            message.OwnerId = reader.readMessage(NeoFsV2Refs.OwnerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // CreationEpoch
          if (wireType === 0) { // Varint
            message.CreationEpoch = reader.readUint64();
          } else if (wireType === 1) { // 64-bit
            message.CreationEpoch = reader.readUint64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 5: // PayloadLength
          if (wireType === 0) { // Varint
            message.PayloadLength = reader.readUint64();
          } else if (wireType === 1) { // 64-bit
            message.PayloadLength = reader.readUint64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 6: // PayloadHash
          if (wireType === 2) { // Length-delimited
            message.PayloadHash = reader.readMessage(NeoFsV2Refs.ChecksumImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 7: // ObjectType
          if (wireType === 0) { // Varint
            message.ObjectType = reader.readEnum();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 8: // HomomorphicHash
          if (wireType === 2) { // Length-delimited
            message.HomomorphicHash = reader.readMessage(NeoFsV2Refs.ChecksumImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 9: // SessionToken
          if (wireType === 2) { // Length-delimited
            message.SessionToken = reader.readMessage(NeoFsV2Session.SessionTokenImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 10: // Attributes
          if (wireType === 2) { // Length-delimited
            message.Attributes.push(reader.readMessage(Header_AttributeImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 11: // Split
          if (wireType === 2) { // Length-delimited
            message.Split = reader.readMessage(Header_SplitImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 12: // SessionTokenV2
          if (wireType === 2) { // Length-delimited
            message.SessionTokenV2 = reader.readMessage(NeoFsV2Session.SessionTokenV2Impl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): HeaderData {
    return {
      Version: this.Version,
      ContainerId: this.ContainerId,
      OwnerId: this.OwnerId,
      CreationEpoch: this.CreationEpoch,
      PayloadLength: this.PayloadLength,
      PayloadHash: this.PayloadHash,
      ObjectType: this.ObjectType,
      HomomorphicHash: this.HomomorphicHash,
      SessionToken: this.SessionToken,
      Attributes: this.Attributes,
      Split: this.Split,
      SessionTokenV2: this.SessionTokenV2
    };
  }

}

// Export class alias without Impl suffix for Node.js compatibility
export class Header extends HeaderImpl {}

// Type for interface data only (excludes class methods from merged type)
export type HeaderData = Omit<Header, 'serializeBinary' | 'toObject' | 'constructor'>;

export interface Header_Attribute {
  Key: string;
  Value: string;
}

export class Header_AttributeImpl implements Header_Attribute {
  Key!: string;
  Value!: string;

  constructor(data?: Partial<Header_Attribute>) {
    this.Key = data?.Key ?? "";
    this.Value = data?.Value ?? "";
  }

  serializeBinary(): Uint8Array {
    const writer = new BinaryWriter();

    if (this.Key !== "") {
      writer.writeString(1, this.Key);
    }
    if (this.Value !== "") {
      writer.writeString(2, this.Value);
    }
    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): Header_AttributeImpl {
    const reader = new BinaryReader(data);
    const message = new Header_AttributeImpl();

    // Parse protobuf wire format
    while (reader.position < reader.buffer.length) {
      const tag = reader.readVarint();
      const fieldNumber = tag >>> 3;
      const wireType = tag & 7;

      switch (fieldNumber) {
        case 1: // Key
          if (wireType === 2) { // Length-delimited
            message.Key = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Value
          if (wireType === 2) { // Length-delimited
            message.Value = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): Header_AttributeData {
    return {
      Key: this.Key,
      Value: this.Value
    };
  }

}

// Export class alias without Impl suffix for Node.js compatibility
export class Header_Attribute extends Header_AttributeImpl {}

// Type for interface data only (excludes class methods from merged type)
export type Header_AttributeData = Omit<Header_Attribute, 'serializeBinary' | 'toObject' | 'constructor'>;

export interface Header_Split {
  Parent?: NeoFsV2Refs.ObjectID;
  Previous?: NeoFsV2Refs.ObjectID;
  ParentSignature?: NeoFsV2Refs.Signature;
  ParentHeader?: Header;
  Children: NeoFsV2Refs.ObjectID[];
  SplitId: Uint8Array;
  First?: NeoFsV2Refs.ObjectID;
}

export class Header_SplitImpl implements Header_Split {
  Parent?: NeoFsV2Refs.ObjectID;
  Previous?: NeoFsV2Refs.ObjectID;
  ParentSignature?: NeoFsV2Refs.Signature;
  ParentHeader?: Header;
  Children!: NeoFsV2Refs.ObjectID[];
  SplitId!: Uint8Array;
  First?: NeoFsV2Refs.ObjectID;

  constructor(data?: Partial<Header_Split>) {
    this.Parent = data?.Parent ?? undefined;
    this.Previous = data?.Previous ?? undefined;
    this.ParentSignature = data?.ParentSignature ?? undefined;
    this.ParentHeader = data?.ParentHeader ?? undefined;
    this.Children = data?.Children ?? [];
    this.SplitId = data?.SplitId ?? new Uint8Array(0);
    this.First = data?.First ?? undefined;
  }

  serializeBinary(): Uint8Array {
    const writer = new BinaryWriter();

    if (this.Parent) {
      writer.writeMessage(1, this.Parent);
    }
    if (this.Previous) {
      writer.writeMessage(2, this.Previous);
    }
    if (this.ParentSignature) {
      writer.writeMessage(3, this.ParentSignature);
    }
    if (this.ParentHeader) {
      writer.writeMessage(4, this.ParentHeader);
    }
    for (const item of this.Children) {
      writer.writeMessage(5, item);
    }
    if (this.SplitId.length > 0) {
      writer.writeBytes(6, this.SplitId);
    }
    if (this.First) {
      writer.writeMessage(7, this.First);
    }
    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): Header_SplitImpl {
    const reader = new BinaryReader(data);
    const message = new Header_SplitImpl();

    // Parse protobuf wire format
    while (reader.position < reader.buffer.length) {
      const tag = reader.readVarint();
      const fieldNumber = tag >>> 3;
      const wireType = tag & 7;

      switch (fieldNumber) {
        case 1: // Parent
          if (wireType === 2) { // Length-delimited
            message.Parent = reader.readMessage(NeoFsV2Refs.ObjectIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Previous
          if (wireType === 2) { // Length-delimited
            message.Previous = reader.readMessage(NeoFsV2Refs.ObjectIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // ParentSignature
          if (wireType === 2) { // Length-delimited
            message.ParentSignature = reader.readMessage(NeoFsV2Refs.SignatureImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // ParentHeader
          if (wireType === 2) { // Length-delimited
            message.ParentHeader = reader.readMessage(HeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 5: // Children
          if (wireType === 2) { // Length-delimited
            message.Children.push(reader.readMessage(NeoFsV2Refs.ObjectIDImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 6: // SplitId
          if (wireType === 2) { // Length-delimited
            message.SplitId = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 7: // First
          if (wireType === 2) { // Length-delimited
            message.First = reader.readMessage(NeoFsV2Refs.ObjectIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): Header_SplitData {
    return {
      Parent: this.Parent,
      Previous: this.Previous,
      ParentSignature: this.ParentSignature,
      ParentHeader: this.ParentHeader,
      Children: this.Children,
      SplitId: this.SplitId,
      First: this.First
    };
  }

}

// Export class alias without Impl suffix for Node.js compatibility
export class Header_Split extends Header_SplitImpl {}

// Type for interface data only (excludes class methods from merged type)
export type Header_SplitData = Omit<Header_Split, 'serializeBinary' | 'toObject' | 'constructor'>;

export interface Object {
  ObjectId?: NeoFsV2Refs.ObjectID;
  Signature?: NeoFsV2Refs.Signature;
  Header?: Header;
  Payload: Uint8Array;
}

export class ObjectImpl implements Object {
  ObjectId?: NeoFsV2Refs.ObjectID;
  Signature?: NeoFsV2Refs.Signature;
  Header?: Header;
  Payload!: Uint8Array;

  constructor(data?: Partial<Object>) {
    this.ObjectId = data?.ObjectId ?? undefined;
    this.Signature = data?.Signature ?? undefined;
    this.Header = data?.Header ?? undefined;
    this.Payload = data?.Payload ?? new Uint8Array(0);
  }

  serializeBinary(): Uint8Array {
    const writer = new BinaryWriter();

    if (this.ObjectId) {
      writer.writeMessage(1, this.ObjectId);
    }
    if (this.Signature) {
      writer.writeMessage(2, this.Signature);
    }
    if (this.Header) {
      writer.writeMessage(3, this.Header);
    }
    if (this.Payload.length > 0) {
      writer.writeBytes(4, this.Payload);
    }
    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): ObjectImpl {
    const reader = new BinaryReader(data);
    const message = new ObjectImpl();

    // Parse protobuf wire format
    while (reader.position < reader.buffer.length) {
      const tag = reader.readVarint();
      const fieldNumber = tag >>> 3;
      const wireType = tag & 7;

      switch (fieldNumber) {
        case 1: // ObjectId
          if (wireType === 2) { // Length-delimited
            message.ObjectId = reader.readMessage(NeoFsV2Refs.ObjectIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Signature
          if (wireType === 2) { // Length-delimited
            message.Signature = reader.readMessage(NeoFsV2Refs.SignatureImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Header
          if (wireType === 2) { // Length-delimited
            message.Header = reader.readMessage(HeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // Payload
          if (wireType === 2) { // Length-delimited
            message.Payload = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): ObjectData {
    return {
      ObjectId: this.ObjectId,
      Signature: this.Signature,
      Header: this.Header,
      Payload: this.Payload
    };
  }

}

// Type for interface data only (class alias skipped for reserved name)
export type ObjectData = Object;

export interface SplitInfo {
  SplitId: Uint8Array;
  LastPart?: NeoFsV2Refs.ObjectID;
  Link?: NeoFsV2Refs.ObjectID;
  FirstPart?: NeoFsV2Refs.ObjectID;
}

export class SplitInfoImpl implements SplitInfo {
  SplitId!: Uint8Array;
  LastPart?: NeoFsV2Refs.ObjectID;
  Link?: NeoFsV2Refs.ObjectID;
  FirstPart?: NeoFsV2Refs.ObjectID;

  constructor(data?: Partial<SplitInfo>) {
    this.SplitId = data?.SplitId ?? new Uint8Array(0);
    this.LastPart = data?.LastPart ?? undefined;
    this.Link = data?.Link ?? undefined;
    this.FirstPart = data?.FirstPart ?? undefined;
  }

  serializeBinary(): Uint8Array {
    const writer = new BinaryWriter();

    if (this.SplitId.length > 0) {
      writer.writeBytes(1, this.SplitId);
    }
    if (this.LastPart) {
      writer.writeMessage(2, this.LastPart);
    }
    if (this.Link) {
      writer.writeMessage(3, this.Link);
    }
    if (this.FirstPart) {
      writer.writeMessage(4, this.FirstPart);
    }
    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): SplitInfoImpl {
    const reader = new BinaryReader(data);
    const message = new SplitInfoImpl();

    // Parse protobuf wire format
    while (reader.position < reader.buffer.length) {
      const tag = reader.readVarint();
      const fieldNumber = tag >>> 3;
      const wireType = tag & 7;

      switch (fieldNumber) {
        case 1: // SplitId
          if (wireType === 2) { // Length-delimited
            message.SplitId = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // LastPart
          if (wireType === 2) { // Length-delimited
            message.LastPart = reader.readMessage(NeoFsV2Refs.ObjectIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Link
          if (wireType === 2) { // Length-delimited
            message.Link = reader.readMessage(NeoFsV2Refs.ObjectIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // FirstPart
          if (wireType === 2) { // Length-delimited
            message.FirstPart = reader.readMessage(NeoFsV2Refs.ObjectIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SplitInfoData {
    return {
      SplitId: this.SplitId,
      LastPart: this.LastPart,
      Link: this.Link,
      FirstPart: this.FirstPart
    };
  }

}

// Export class alias without Impl suffix for Node.js compatibility
export class SplitInfo extends SplitInfoImpl {}

// Type for interface data only (excludes class methods from merged type)
export type SplitInfoData = Omit<SplitInfo, 'serializeBinary' | 'toObject' | 'constructor'>;

} // namespace NeoFsV2Object