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

import { NeoFsV2Session } from '../session/types_pb';
import { NeoFsV2Refs } from '../refs/types_pb';
import { NeoFsV2Object } from './types_pb';
import { NeoFsV2Status } from '../status/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 interface GetRequest {
  Body?: GetRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class GetRequestImpl implements GetRequest {
  Body?: GetRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<GetRequest>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(GetRequest_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.RequestMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.RequestVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetRequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface GetRequest_Body {
  Address?: NeoFsV2Refs.Address;
  Raw: boolean;
}

export class GetRequest_BodyImpl implements GetRequest_Body {
  Address?: NeoFsV2Refs.Address;
  Raw!: boolean;

  constructor(data?: Partial<GetRequest_Body>) {
    this.Address = data?.Address ?? undefined;
    this.Raw = data?.Raw ?? false;
  }

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

    if (this.Address) {
      writer.writeMessage(1, this.Address);
    }
    if (this.Raw !== false) {
      writer.writeBool(2, this.Raw);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Address
          if (wireType === 2) { // Length-delimited
            message.Address = reader.readMessage(NeoFsV2Refs.AddressImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Raw
          if (wireType === 0) { // Varint
            message.Raw = reader.readBool();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetRequest_BodyData {
    return {
      Address: this.Address,
      Raw: this.Raw
    };
  }

}

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

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

export interface GetResponse {
  Body?: GetResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class GetResponseImpl implements GetResponse {
  Body?: GetResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<GetResponse>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(GetResponse_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.ResponseMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.ResponseVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface GetResponse_Body {
  Init?: GetResponse_Body_Init;
  Chunk: Uint8Array;
  SplitInfo?: NeoFsV2Object.SplitInfo;
}

export class GetResponse_BodyImpl implements GetResponse_Body {
  Init?: GetResponse_Body_Init;
  Chunk!: Uint8Array;
  SplitInfo?: NeoFsV2Object.SplitInfo;

  constructor(data?: Partial<GetResponse_Body>) {
    this.Init = data?.Init ?? undefined;
    this.Chunk = data?.Chunk ?? new Uint8Array(0);
    this.SplitInfo = data?.SplitInfo ?? undefined;
  }

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

    if (this.Init) {
      writer.writeMessage(1, this.Init);
    }
    if (this.Chunk.length > 0) {
      writer.writeBytes(2, this.Chunk);
    }
    if (this.SplitInfo) {
      writer.writeMessage(3, this.SplitInfo);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Init
          if (wireType === 2) { // Length-delimited
            message.Init = reader.readMessage(GetResponse_Body_InitImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Chunk
          if (wireType === 2) { // Length-delimited
            message.Chunk = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // SplitInfo
          if (wireType === 2) { // Length-delimited
            message.SplitInfo = reader.readMessage(NeoFsV2Object.SplitInfoImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetResponse_BodyData {
    return {
      Init: this.Init,
      Chunk: this.Chunk,
      SplitInfo: this.SplitInfo
    };
  }

}

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

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

export interface GetResponse_Body_Init {
  ObjectId?: NeoFsV2Refs.ObjectID;
  Signature?: NeoFsV2Refs.Signature;
  Header?: NeoFsV2Object.Header;
}

export class GetResponse_Body_InitImpl implements GetResponse_Body_Init {
  ObjectId?: NeoFsV2Refs.ObjectID;
  Signature?: NeoFsV2Refs.Signature;
  Header?: NeoFsV2Object.Header;

  constructor(data?: Partial<GetResponse_Body_Init>) {
    this.ObjectId = data?.ObjectId ?? undefined;
    this.Signature = data?.Signature ?? undefined;
    this.Header = data?.Header ?? undefined;
  }

  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);
    }
    return writer.getResultBuffer();
  }

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

    // 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(NeoFsV2Object.HeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

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

}

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

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

export interface PutRequest {
  Body?: PutRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class PutRequestImpl implements PutRequest {
  Body?: PutRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<PutRequest>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(PutRequest_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.RequestMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.RequestVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): PutRequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface PutRequest_Body {
  Init?: PutRequest_Body_Init;
  Chunk: Uint8Array;
}

export class PutRequest_BodyImpl implements PutRequest_Body {
  Init?: PutRequest_Body_Init;
  Chunk!: Uint8Array;

  constructor(data?: Partial<PutRequest_Body>) {
    this.Init = data?.Init ?? undefined;
    this.Chunk = data?.Chunk ?? new Uint8Array(0);
  }

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

    if (this.Init) {
      writer.writeMessage(1, this.Init);
    }
    if (this.Chunk.length > 0) {
      writer.writeBytes(2, this.Chunk);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Init
          if (wireType === 2) { // Length-delimited
            message.Init = reader.readMessage(PutRequest_Body_InitImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Chunk
          if (wireType === 2) { // Length-delimited
            message.Chunk = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): PutRequest_BodyData {
    return {
      Init: this.Init,
      Chunk: this.Chunk
    };
  }

}

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

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

export interface PutRequest_Body_Init {
  ObjectId?: NeoFsV2Refs.ObjectID;
  Signature?: NeoFsV2Refs.Signature;
  Header?: NeoFsV2Object.Header;
  CopiesNumber: number;
}

export class PutRequest_Body_InitImpl implements PutRequest_Body_Init {
  ObjectId?: NeoFsV2Refs.ObjectID;
  Signature?: NeoFsV2Refs.Signature;
  Header?: NeoFsV2Object.Header;
  CopiesNumber!: number;

  constructor(data?: Partial<PutRequest_Body_Init>) {
    this.ObjectId = data?.ObjectId ?? undefined;
    this.Signature = data?.Signature ?? undefined;
    this.Header = data?.Header ?? undefined;
    this.CopiesNumber = data?.CopiesNumber ?? 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.CopiesNumber !== 0) {
      writer.writeUint32(4, this.CopiesNumber);
    }
    return writer.getResultBuffer();
  }

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

    // 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(NeoFsV2Object.HeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // CopiesNumber
          if (wireType === 0) { // Varint
            message.CopiesNumber = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.CopiesNumber = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): PutRequest_Body_InitData {
    return {
      ObjectId: this.ObjectId,
      Signature: this.Signature,
      Header: this.Header,
      CopiesNumber: this.CopiesNumber
    };
  }

}

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

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

export interface PutResponse {
  Body?: PutResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class PutResponseImpl implements PutResponse {
  Body?: PutResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<PutResponse>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(PutResponse_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.ResponseMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.ResponseVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): PutResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface PutResponse_Body {
  ObjectId?: NeoFsV2Refs.ObjectID;
}

export class PutResponse_BodyImpl implements PutResponse_Body {
  ObjectId?: NeoFsV2Refs.ObjectID;

  constructor(data?: Partial<PutResponse_Body>) {
    this.ObjectId = data?.ObjectId ?? undefined;
  }

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

    if (this.ObjectId) {
      writer.writeMessage(1, this.ObjectId);
    }
    return writer.getResultBuffer();
  }

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

    // 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;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): PutResponse_BodyData {
    return {
      ObjectId: this.ObjectId
    };
  }

}

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

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

export interface DeleteRequest {
  Body?: DeleteRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class DeleteRequestImpl implements DeleteRequest {
  Body?: DeleteRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<DeleteRequest>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(DeleteRequest_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.RequestMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.RequestVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): DeleteRequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface DeleteRequest_Body {
  Address?: NeoFsV2Refs.Address;
}

export class DeleteRequest_BodyImpl implements DeleteRequest_Body {
  Address?: NeoFsV2Refs.Address;

  constructor(data?: Partial<DeleteRequest_Body>) {
    this.Address = data?.Address ?? undefined;
  }

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

    if (this.Address) {
      writer.writeMessage(1, this.Address);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Address
          if (wireType === 2) { // Length-delimited
            message.Address = reader.readMessage(NeoFsV2Refs.AddressImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): DeleteRequest_BodyData {
    return {
      Address: this.Address
    };
  }

}

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

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

export interface DeleteResponse {
  Body?: DeleteResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class DeleteResponseImpl implements DeleteResponse {
  Body?: DeleteResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<DeleteResponse>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(DeleteResponse_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.ResponseMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.ResponseVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): DeleteResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface DeleteResponse_Body {
  Tombstone?: NeoFsV2Refs.Address;
}

export class DeleteResponse_BodyImpl implements DeleteResponse_Body {
  Tombstone?: NeoFsV2Refs.Address;

  constructor(data?: Partial<DeleteResponse_Body>) {
    this.Tombstone = data?.Tombstone ?? undefined;
  }

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

    if (this.Tombstone) {
      writer.writeMessage(1, this.Tombstone);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Tombstone
          if (wireType === 2) { // Length-delimited
            message.Tombstone = reader.readMessage(NeoFsV2Refs.AddressImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): DeleteResponse_BodyData {
    return {
      Tombstone: this.Tombstone
    };
  }

}

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

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

export interface HeadRequest {
  Body?: HeadRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class HeadRequestImpl implements HeadRequest {
  Body?: HeadRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<HeadRequest>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(HeadRequest_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.RequestMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.RequestVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): HeadRequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface HeadRequest_Body {
  Address?: NeoFsV2Refs.Address;
  MainOnly: boolean;
  Raw: boolean;
}

export class HeadRequest_BodyImpl implements HeadRequest_Body {
  Address?: NeoFsV2Refs.Address;
  MainOnly!: boolean;
  Raw!: boolean;

  constructor(data?: Partial<HeadRequest_Body>) {
    this.Address = data?.Address ?? undefined;
    this.MainOnly = data?.MainOnly ?? false;
    this.Raw = data?.Raw ?? false;
  }

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

    if (this.Address) {
      writer.writeMessage(1, this.Address);
    }
    if (this.MainOnly !== false) {
      writer.writeBool(2, this.MainOnly);
    }
    if (this.Raw !== false) {
      writer.writeBool(3, this.Raw);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Address
          if (wireType === 2) { // Length-delimited
            message.Address = reader.readMessage(NeoFsV2Refs.AddressImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MainOnly
          if (wireType === 0) { // Varint
            message.MainOnly = reader.readBool();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Raw
          if (wireType === 0) { // Varint
            message.Raw = reader.readBool();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): HeadRequest_BodyData {
    return {
      Address: this.Address,
      MainOnly: this.MainOnly,
      Raw: this.Raw
    };
  }

}

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

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

export interface HeaderWithSignature {
  Header?: NeoFsV2Object.Header;
  Signature?: NeoFsV2Refs.Signature;
}

export class HeaderWithSignatureImpl implements HeaderWithSignature {
  Header?: NeoFsV2Object.Header;
  Signature?: NeoFsV2Refs.Signature;

  constructor(data?: Partial<HeaderWithSignature>) {
    this.Header = data?.Header ?? undefined;
    this.Signature = data?.Signature ?? undefined;
  }

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

    if (this.Header) {
      writer.writeMessage(1, this.Header);
    }
    if (this.Signature) {
      writer.writeMessage(2, this.Signature);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Header
          if (wireType === 2) { // Length-delimited
            message.Header = reader.readMessage(NeoFsV2Object.HeaderImpl.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;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): HeaderWithSignatureData {
    return {
      Header: this.Header,
      Signature: this.Signature
    };
  }

}

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

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

export interface HeadResponse {
  Body?: HeadResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class HeadResponseImpl implements HeadResponse {
  Body?: HeadResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<HeadResponse>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(HeadResponse_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.ResponseMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.ResponseVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): HeadResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface HeadResponse_Body {
  Header?: HeaderWithSignature;
  ShortHeader?: NeoFsV2Object.ShortHeader;
  SplitInfo?: NeoFsV2Object.SplitInfo;
}

export class HeadResponse_BodyImpl implements HeadResponse_Body {
  Header?: HeaderWithSignature;
  ShortHeader?: NeoFsV2Object.ShortHeader;
  SplitInfo?: NeoFsV2Object.SplitInfo;

  constructor(data?: Partial<HeadResponse_Body>) {
    this.Header = data?.Header ?? undefined;
    this.ShortHeader = data?.ShortHeader ?? undefined;
    this.SplitInfo = data?.SplitInfo ?? undefined;
  }

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

    if (this.Header) {
      writer.writeMessage(1, this.Header);
    }
    if (this.ShortHeader) {
      writer.writeMessage(2, this.ShortHeader);
    }
    if (this.SplitInfo) {
      writer.writeMessage(3, this.SplitInfo);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Header
          if (wireType === 2) { // Length-delimited
            message.Header = reader.readMessage(HeaderWithSignatureImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // ShortHeader
          if (wireType === 2) { // Length-delimited
            message.ShortHeader = reader.readMessage(NeoFsV2Object.ShortHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // SplitInfo
          if (wireType === 2) { // Length-delimited
            message.SplitInfo = reader.readMessage(NeoFsV2Object.SplitInfoImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): HeadResponse_BodyData {
    return {
      Header: this.Header,
      ShortHeader: this.ShortHeader,
      SplitInfo: this.SplitInfo
    };
  }

}

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

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

export interface SearchRequest {
  Body?: SearchRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class SearchRequestImpl implements SearchRequest {
  Body?: SearchRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<SearchRequest>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(SearchRequest_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.RequestMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.RequestVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SearchRequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface SearchRequest_Body {
  ContainerId?: NeoFsV2Refs.ContainerID;
  Version: number;
  Filters: NeoFsV2Object.SearchFilter[];
}

export class SearchRequest_BodyImpl implements SearchRequest_Body {
  ContainerId?: NeoFsV2Refs.ContainerID;
  Version!: number;
  Filters!: NeoFsV2Object.SearchFilter[];

  constructor(data?: Partial<SearchRequest_Body>) {
    this.ContainerId = data?.ContainerId ?? undefined;
    this.Version = data?.Version ?? 0;
    this.Filters = data?.Filters ?? [];
  }

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

    if (this.ContainerId) {
      writer.writeMessage(1, this.ContainerId);
    }
    if (this.Version !== 0) {
      writer.writeUint32(2, this.Version);
    }
    for (const item of this.Filters) {
      writer.writeMessage(3, item);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // ContainerId
          if (wireType === 2) { // Length-delimited
            message.ContainerId = reader.readMessage(NeoFsV2Refs.ContainerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Version
          if (wireType === 0) { // Varint
            message.Version = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.Version = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Filters
          if (wireType === 2) { // Length-delimited
            message.Filters.push(reader.readMessage(NeoFsV2Object.SearchFilterImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SearchRequest_BodyData {
    return {
      ContainerId: this.ContainerId,
      Version: this.Version,
      Filters: this.Filters
    };
  }

}

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

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

export interface SearchResponse {
  Body?: SearchResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class SearchResponseImpl implements SearchResponse {
  Body?: SearchResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<SearchResponse>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(SearchResponse_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.ResponseMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.ResponseVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SearchResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface SearchResponse_Body {
  IdList: NeoFsV2Refs.ObjectID[];
}

export class SearchResponse_BodyImpl implements SearchResponse_Body {
  IdList!: NeoFsV2Refs.ObjectID[];

  constructor(data?: Partial<SearchResponse_Body>) {
    this.IdList = data?.IdList ?? [];
  }

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

    for (const item of this.IdList) {
      writer.writeMessage(1, item);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // IdList
          if (wireType === 2) { // Length-delimited
            message.IdList.push(reader.readMessage(NeoFsV2Refs.ObjectIDImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SearchResponse_BodyData {
    return {
      IdList: this.IdList
    };
  }

}

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

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

export interface SearchV2Request {
  Body?: SearchV2Request_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class SearchV2RequestImpl implements SearchV2Request {
  Body?: SearchV2Request_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<SearchV2Request>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(SearchV2Request_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.RequestMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.RequestVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SearchV2RequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface SearchV2Request_Body {
  ContainerId?: NeoFsV2Refs.ContainerID;
  Version: number;
  Filters: NeoFsV2Object.SearchFilter[];
  Cursor: string;
  Count: number;
  Attributes: string[];
}

export class SearchV2Request_BodyImpl implements SearchV2Request_Body {
  ContainerId?: NeoFsV2Refs.ContainerID;
  Version!: number;
  Filters!: NeoFsV2Object.SearchFilter[];
  Cursor!: string;
  Count!: number;
  Attributes!: string[];

  constructor(data?: Partial<SearchV2Request_Body>) {
    this.ContainerId = data?.ContainerId ?? undefined;
    this.Version = data?.Version ?? 0;
    this.Filters = data?.Filters ?? [];
    this.Cursor = data?.Cursor ?? "";
    this.Count = data?.Count ?? 0;
    this.Attributes = data?.Attributes ?? [];
  }

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

    if (this.ContainerId) {
      writer.writeMessage(1, this.ContainerId);
    }
    if (this.Version !== 0) {
      writer.writeUint32(2, this.Version);
    }
    for (const item of this.Filters) {
      writer.writeMessage(3, item);
    }
    if (this.Cursor !== "") {
      writer.writeString(4, this.Cursor);
    }
    if (this.Count !== 0) {
      writer.writeUint32(5, this.Count);
    }
    for (const item of this.Attributes) {
      writer.writeString(6, item);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // ContainerId
          if (wireType === 2) { // Length-delimited
            message.ContainerId = reader.readMessage(NeoFsV2Refs.ContainerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Version
          if (wireType === 0) { // Varint
            message.Version = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.Version = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Filters
          if (wireType === 2) { // Length-delimited
            message.Filters.push(reader.readMessage(NeoFsV2Object.SearchFilterImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // Cursor
          if (wireType === 2) { // Length-delimited
            message.Cursor = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 5: // Count
          if (wireType === 0) { // Varint
            message.Count = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.Count = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 6: // Attributes
          if (wireType === 2) { // Length-delimited
            message.Attributes.push(reader.readString());
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SearchV2Request_BodyData {
    return {
      ContainerId: this.ContainerId,
      Version: this.Version,
      Filters: this.Filters,
      Cursor: this.Cursor,
      Count: this.Count,
      Attributes: this.Attributes
    };
  }

}

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

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

export interface SearchV2Response {
  Body?: SearchV2Response_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class SearchV2ResponseImpl implements SearchV2Response {
  Body?: SearchV2Response_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<SearchV2Response>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(SearchV2Response_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.ResponseMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.ResponseVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SearchV2ResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface SearchV2Response_OIDWithMeta {
  Id?: NeoFsV2Refs.ObjectID;
  Attributes: string[];
}

export class SearchV2Response_OIDWithMetaImpl implements SearchV2Response_OIDWithMeta {
  Id?: NeoFsV2Refs.ObjectID;
  Attributes!: string[];

  constructor(data?: Partial<SearchV2Response_OIDWithMeta>) {
    this.Id = data?.Id ?? undefined;
    this.Attributes = data?.Attributes ?? [];
  }

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

    if (this.Id) {
      writer.writeMessage(1, this.Id);
    }
    for (const item of this.Attributes) {
      writer.writeString(2, item);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Id
          if (wireType === 2) { // Length-delimited
            message.Id = reader.readMessage(NeoFsV2Refs.ObjectIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Attributes
          if (wireType === 2) { // Length-delimited
            message.Attributes.push(reader.readString());
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SearchV2Response_OIDWithMetaData {
    return {
      Id: this.Id,
      Attributes: this.Attributes
    };
  }

}

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

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

export interface SearchV2Response_Body {
  Result: SearchV2Response_OIDWithMeta[];
  Cursor: string;
}

export class SearchV2Response_BodyImpl implements SearchV2Response_Body {
  Result!: SearchV2Response_OIDWithMeta[];
  Cursor!: string;

  constructor(data?: Partial<SearchV2Response_Body>) {
    this.Result = data?.Result ?? [];
    this.Cursor = data?.Cursor ?? "";
  }

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

    for (const item of this.Result) {
      writer.writeMessage(1, item);
    }
    if (this.Cursor !== "") {
      writer.writeString(2, this.Cursor);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Result
          if (wireType === 2) { // Length-delimited
            message.Result.push(reader.readMessage(SearchV2Response_OIDWithMetaImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Cursor
          if (wireType === 2) { // Length-delimited
            message.Cursor = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SearchV2Response_BodyData {
    return {
      Result: this.Result,
      Cursor: this.Cursor
    };
  }

}

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

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

export interface Range {
  Offset: bigint;
  Length: bigint;
}

export class RangeImpl implements Range {
  Offset!: bigint;
  Length!: bigint;

  constructor(data?: Partial<Range>) {
    this.Offset = data?.Offset ?? 0n;
    this.Length = data?.Length ?? 0n;
  }

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

    if (this.Offset !== 0n) {
      writer.writeUint64(1, this.Offset);
    }
    if (this.Length !== 0n) {
      writer.writeUint64(2, this.Length);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Offset
          if (wireType === 0) { // Varint
            message.Offset = reader.readUint64();
          } else if (wireType === 1) { // 64-bit
            message.Offset = reader.readUint64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Length
          if (wireType === 0) { // Varint
            message.Length = reader.readUint64();
          } else if (wireType === 1) { // 64-bit
            message.Length = reader.readUint64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): RangeData {
    return {
      Offset: this.Offset,
      Length: this.Length
    };
  }

}

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

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

export interface GetRangeRequest {
  Body?: GetRangeRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class GetRangeRequestImpl implements GetRangeRequest {
  Body?: GetRangeRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<GetRangeRequest>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(GetRangeRequest_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.RequestMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.RequestVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetRangeRequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface GetRangeRequest_Body {
  Address?: NeoFsV2Refs.Address;
  Range?: Range;
  Raw: boolean;
}

export class GetRangeRequest_BodyImpl implements GetRangeRequest_Body {
  Address?: NeoFsV2Refs.Address;
  Range?: Range;
  Raw!: boolean;

  constructor(data?: Partial<GetRangeRequest_Body>) {
    this.Address = data?.Address ?? undefined;
    this.Range = data?.Range ?? undefined;
    this.Raw = data?.Raw ?? false;
  }

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

    if (this.Address) {
      writer.writeMessage(1, this.Address);
    }
    if (this.Range) {
      writer.writeMessage(2, this.Range);
    }
    if (this.Raw !== false) {
      writer.writeBool(3, this.Raw);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Address
          if (wireType === 2) { // Length-delimited
            message.Address = reader.readMessage(NeoFsV2Refs.AddressImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Range
          if (wireType === 2) { // Length-delimited
            message.Range = reader.readMessage(RangeImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Raw
          if (wireType === 0) { // Varint
            message.Raw = reader.readBool();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetRangeRequest_BodyData {
    return {
      Address: this.Address,
      Range: this.Range,
      Raw: this.Raw
    };
  }

}

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

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

export interface GetRangeResponse {
  Body?: GetRangeResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class GetRangeResponseImpl implements GetRangeResponse {
  Body?: GetRangeResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<GetRangeResponse>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(GetRangeResponse_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.ResponseMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.ResponseVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetRangeResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface GetRangeResponse_Body {
  Chunk: Uint8Array;
  SplitInfo?: NeoFsV2Object.SplitInfo;
}

export class GetRangeResponse_BodyImpl implements GetRangeResponse_Body {
  Chunk!: Uint8Array;
  SplitInfo?: NeoFsV2Object.SplitInfo;

  constructor(data?: Partial<GetRangeResponse_Body>) {
    this.Chunk = data?.Chunk ?? new Uint8Array(0);
    this.SplitInfo = data?.SplitInfo ?? undefined;
  }

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

    if (this.Chunk.length > 0) {
      writer.writeBytes(1, this.Chunk);
    }
    if (this.SplitInfo) {
      writer.writeMessage(2, this.SplitInfo);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Chunk
          if (wireType === 2) { // Length-delimited
            message.Chunk = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // SplitInfo
          if (wireType === 2) { // Length-delimited
            message.SplitInfo = reader.readMessage(NeoFsV2Object.SplitInfoImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetRangeResponse_BodyData {
    return {
      Chunk: this.Chunk,
      SplitInfo: this.SplitInfo
    };
  }

}

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

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

export interface GetRangeHashRequest {
  Body?: GetRangeHashRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class GetRangeHashRequestImpl implements GetRangeHashRequest {
  Body?: GetRangeHashRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<GetRangeHashRequest>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(GetRangeHashRequest_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.RequestMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.RequestVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetRangeHashRequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface GetRangeHashRequest_Body {
  Address?: NeoFsV2Refs.Address;
  Ranges: Range[];
  Salt: Uint8Array;
  Type: ChecksumType;
}

export class GetRangeHashRequest_BodyImpl implements GetRangeHashRequest_Body {
  Address?: NeoFsV2Refs.Address;
  Ranges!: Range[];
  Salt!: Uint8Array;
  Type!: ChecksumType;

  constructor(data?: Partial<GetRangeHashRequest_Body>) {
    this.Address = data?.Address ?? undefined;
    this.Ranges = data?.Ranges ?? [];
    this.Salt = data?.Salt ?? new Uint8Array(0);
    this.Type = data?.Type ?? 0;
  }

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

    if (this.Address) {
      writer.writeMessage(1, this.Address);
    }
    for (const item of this.Ranges) {
      writer.writeMessage(2, item);
    }
    if (this.Salt.length > 0) {
      writer.writeBytes(3, this.Salt);
    }
    if (this.Type !== 0) {
      writer.writeEnum(4, this.Type);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Address
          if (wireType === 2) { // Length-delimited
            message.Address = reader.readMessage(NeoFsV2Refs.AddressImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Ranges
          if (wireType === 2) { // Length-delimited
            message.Ranges.push(reader.readMessage(RangeImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Salt
          if (wireType === 2) { // Length-delimited
            message.Salt = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // Type
          if (wireType === 0) { // Varint
            message.Type = reader.readEnum();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetRangeHashRequest_BodyData {
    return {
      Address: this.Address,
      Ranges: this.Ranges,
      Salt: this.Salt,
      Type: this.Type
    };
  }

}

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

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

export interface GetRangeHashResponse {
  Body?: GetRangeHashResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class GetRangeHashResponseImpl implements GetRangeHashResponse {
  Body?: GetRangeHashResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<GetRangeHashResponse>) {
    this.Body = data?.Body ?? undefined;
    this.MetaHeader = data?.MetaHeader ?? undefined;
    this.VerifyHeader = data?.VerifyHeader ?? undefined;
  }

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

    if (this.Body) {
      writer.writeMessage(1, this.Body);
    }
    if (this.MetaHeader) {
      writer.writeMessage(2, this.MetaHeader);
    }
    if (this.VerifyHeader) {
      writer.writeMessage(3, this.VerifyHeader);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Body
          if (wireType === 2) { // Length-delimited
            message.Body = reader.readMessage(GetRangeHashResponse_BodyImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MetaHeader
          if (wireType === 2) { // Length-delimited
            message.MetaHeader = reader.readMessage(NeoFsV2Session.ResponseMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // VerifyHeader
          if (wireType === 2) { // Length-delimited
            message.VerifyHeader = reader.readMessage(NeoFsV2Session.ResponseVerificationHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetRangeHashResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface GetRangeHashResponse_Body {
  Type: ChecksumType;
  HashList: Uint8Array[];
}

export class GetRangeHashResponse_BodyImpl implements GetRangeHashResponse_Body {
  Type!: ChecksumType;
  HashList!: Uint8Array[];

  constructor(data?: Partial<GetRangeHashResponse_Body>) {
    this.Type = data?.Type ?? 0;
    this.HashList = data?.HashList ?? [];
  }

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

    if (this.Type !== 0) {
      writer.writeEnum(1, this.Type);
    }
    for (const item of this.HashList) {
      writer.writeBytes(2, item);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Type
          if (wireType === 0) { // Varint
            message.Type = reader.readEnum();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // HashList
          if (wireType === 2) { // Length-delimited
            message.HashList.push(reader.readBytes());
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetRangeHashResponse_BodyData {
    return {
      Type: this.Type,
      HashList: this.HashList
    };
  }

}

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

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

export interface ReplicateRequest {
  Object?: NeoFsV2Object.Object;
  Signature?: NeoFsV2Refs.Signature;
  SignObject: boolean;
}

export class ReplicateRequestImpl implements ReplicateRequest {
  Object?: NeoFsV2Object.Object;
  Signature?: NeoFsV2Refs.Signature;
  SignObject!: boolean;

  constructor(data?: Partial<ReplicateRequest>) {
    this.Object = data?.Object ?? undefined;
    this.Signature = data?.Signature ?? undefined;
    this.SignObject = data?.SignObject ?? false;
  }

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

    if (this.Object) {
      writer.writeMessage(1, this.Object);
    }
    if (this.Signature) {
      writer.writeMessage(2, this.Signature);
    }
    if (this.SignObject !== false) {
      writer.writeBool(3, this.SignObject);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Object
          if (wireType === 2) { // Length-delimited
            message.Object = reader.readMessage(NeoFsV2Object.ObjectImpl.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: // SignObject
          if (wireType === 0) { // Varint
            message.SignObject = reader.readBool();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): ReplicateRequestData {
    return {
      Object: this.Object,
      Signature: this.Signature,
      SignObject: this.SignObject
    };
  }

}

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

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

export interface ReplicateResponse {
  Status?: NeoFsV2Status.Status;
  ObjectSignature: Uint8Array;
}

export class ReplicateResponseImpl implements ReplicateResponse {
  Status?: NeoFsV2Status.Status;
  ObjectSignature!: Uint8Array;

  constructor(data?: Partial<ReplicateResponse>) {
    this.Status = data?.Status ?? undefined;
    this.ObjectSignature = data?.ObjectSignature ?? new Uint8Array(0);
  }

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

    if (this.Status) {
      writer.writeMessage(1, this.Status);
    }
    if (this.ObjectSignature.length > 0) {
      writer.writeBytes(2, this.ObjectSignature);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Status
          if (wireType === 2) { // Length-delimited
            message.Status = reader.readMessage(NeoFsV2Status.StatusImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // ObjectSignature
          if (wireType === 2) { // Length-delimited
            message.ObjectSignature = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): ReplicateResponseData {
    return {
      Status: this.Status,
      ObjectSignature: this.ObjectSignature
    };
  }

}

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

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