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

import { NeoFsV2Session } from '../session/types_pb';
import { NeoFsV2Container } from './types_pb';
import { NeoFsV2Refs } from '../refs/types_pb';
import { NeoFsV2Acl } from '../acl/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 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 {
  Container?: NeoFsV2Container.Container;
  Signature?: NeoFsV2Refs.SignatureRFC6979;
}

export class PutRequest_BodyImpl implements PutRequest_Body {
  Container?: NeoFsV2Container.Container;
  Signature?: NeoFsV2Refs.SignatureRFC6979;

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

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

    if (this.Container) {
      writer.writeMessage(1, this.Container);
    }
    if (this.Signature) {
      writer.writeMessage(2, this.Signature);
    }
    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: // Container
          if (wireType === 2) { // Length-delimited
            message.Container = reader.readMessage(NeoFsV2Container.ContainerImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Signature
          if (wireType === 2) { // Length-delimited
            message.Signature = reader.readMessage(NeoFsV2Refs.SignatureRFC6979Impl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): PutRequest_BodyData {
    return {
      Container: this.Container,
      Signature: this.Signature
    };
  }

}

// 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 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 {
  ContainerId?: NeoFsV2Refs.ContainerID;
}

export class PutResponse_BodyImpl implements PutResponse_Body {
  ContainerId?: NeoFsV2Refs.ContainerID;

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

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

    if (this.ContainerId) {
      writer.writeMessage(1, this.ContainerId);
    }
    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: // ContainerId
          if (wireType === 2) { // Length-delimited
            message.ContainerId = reader.readMessage(NeoFsV2Refs.ContainerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

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

}

// 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 {
  ContainerId?: NeoFsV2Refs.ContainerID;
  Signature?: NeoFsV2Refs.SignatureRFC6979;
}

export class DeleteRequest_BodyImpl implements DeleteRequest_Body {
  ContainerId?: NeoFsV2Refs.ContainerID;
  Signature?: NeoFsV2Refs.SignatureRFC6979;

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

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

    if (this.ContainerId) {
      writer.writeMessage(1, this.ContainerId);
    }
    if (this.Signature) {
      writer.writeMessage(2, this.Signature);
    }
    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: // ContainerId
          if (wireType === 2) { // Length-delimited
            message.ContainerId = reader.readMessage(NeoFsV2Refs.ContainerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Signature
          if (wireType === 2) { // Length-delimited
            message.Signature = reader.readMessage(NeoFsV2Refs.SignatureRFC6979Impl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): DeleteRequest_BodyData {
    return {
      ContainerId: this.ContainerId,
      Signature: this.Signature
    };
  }

}

// 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 {
}

export class DeleteResponse_BodyImpl implements DeleteResponse_Body {

  constructor(data?: Partial<DeleteResponse_Body>) {
  }

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

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

    return message;
  }

  toObject(): DeleteResponse_BodyData {
    return {
    };
  }

}

// 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 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 {
  ContainerId?: NeoFsV2Refs.ContainerID;
}

export class GetRequest_BodyImpl implements GetRequest_Body {
  ContainerId?: NeoFsV2Refs.ContainerID;

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

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

    if (this.ContainerId) {
      writer.writeMessage(1, this.ContainerId);
    }
    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: // ContainerId
          if (wireType === 2) { // Length-delimited
            message.ContainerId = reader.readMessage(NeoFsV2Refs.ContainerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetRequest_BodyData {
    return {
      ContainerId: this.ContainerId
    };
  }

}

// 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 {
  Container?: NeoFsV2Container.Container;
  Signature?: NeoFsV2Refs.SignatureRFC6979;
  SessionToken?: NeoFsV2Session.SessionToken;
}

export class GetResponse_BodyImpl implements GetResponse_Body {
  Container?: NeoFsV2Container.Container;
  Signature?: NeoFsV2Refs.SignatureRFC6979;
  SessionToken?: NeoFsV2Session.SessionToken;

  constructor(data?: Partial<GetResponse_Body>) {
    this.Container = data?.Container ?? undefined;
    this.Signature = data?.Signature ?? undefined;
    this.SessionToken = data?.SessionToken ?? undefined;
  }

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

    if (this.Container) {
      writer.writeMessage(1, this.Container);
    }
    if (this.Signature) {
      writer.writeMessage(2, this.Signature);
    }
    if (this.SessionToken) {
      writer.writeMessage(3, this.SessionToken);
    }
    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: // Container
          if (wireType === 2) { // Length-delimited
            message.Container = reader.readMessage(NeoFsV2Container.ContainerImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Signature
          if (wireType === 2) { // Length-delimited
            message.Signature = reader.readMessage(NeoFsV2Refs.SignatureRFC6979Impl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // SessionToken
          if (wireType === 2) { // Length-delimited
            message.SessionToken = reader.readMessage(NeoFsV2Session.SessionTokenImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetResponse_BodyData {
    return {
      Container: this.Container,
      Signature: this.Signature,
      SessionToken: this.SessionToken
    };
  }

}

// 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 ListRequest {
  Body?: ListRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class ListRequestImpl implements ListRequest {
  Body?: ListRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<ListRequest>) {
    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): ListRequestImpl {
    const reader = new BinaryReader(data);
    const message = new ListRequestImpl();

    // 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(ListRequest_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(): ListRequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface ListRequest_Body {
  OwnerId?: NeoFsV2Refs.OwnerID;
}

export class ListRequest_BodyImpl implements ListRequest_Body {
  OwnerId?: NeoFsV2Refs.OwnerID;

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

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

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

  static deserializeBinary(data: Uint8Array): ListRequest_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new ListRequest_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: // OwnerId
          if (wireType === 2) { // Length-delimited
            message.OwnerId = reader.readMessage(NeoFsV2Refs.OwnerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): ListRequest_BodyData {
    return {
      OwnerId: this.OwnerId
    };
  }

}

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

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

export interface ListResponse {
  Body?: ListResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class ListResponseImpl implements ListResponse {
  Body?: ListResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<ListResponse>) {
    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): ListResponseImpl {
    const reader = new BinaryReader(data);
    const message = new ListResponseImpl();

    // 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(ListResponse_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(): ListResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface ListResponse_Body {
  ContainerIds: NeoFsV2Refs.ContainerID[];
}

export class ListResponse_BodyImpl implements ListResponse_Body {
  ContainerIds!: NeoFsV2Refs.ContainerID[];

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

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

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

  static deserializeBinary(data: Uint8Array): ListResponse_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new ListResponse_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: // ContainerIds
          if (wireType === 2) { // Length-delimited
            message.ContainerIds.push(reader.readMessage(NeoFsV2Refs.ContainerIDImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): ListResponse_BodyData {
    return {
      ContainerIds: this.ContainerIds
    };
  }

}

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

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

export interface SetExtendedACLRequest {
  Body?: SetExtendedACLRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class SetExtendedACLRequestImpl implements SetExtendedACLRequest {
  Body?: SetExtendedACLRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<SetExtendedACLRequest>) {
    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): SetExtendedACLRequestImpl {
    const reader = new BinaryReader(data);
    const message = new SetExtendedACLRequestImpl();

    // 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(SetExtendedACLRequest_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(): SetExtendedACLRequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface SetExtendedACLRequest_Body {
  Eacl?: NeoFsV2Acl.EACLTable;
  Signature?: NeoFsV2Refs.SignatureRFC6979;
}

export class SetExtendedACLRequest_BodyImpl implements SetExtendedACLRequest_Body {
  Eacl?: NeoFsV2Acl.EACLTable;
  Signature?: NeoFsV2Refs.SignatureRFC6979;

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

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

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

  static deserializeBinary(data: Uint8Array): SetExtendedACLRequest_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new SetExtendedACLRequest_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: // Eacl
          if (wireType === 2) { // Length-delimited
            message.Eacl = reader.readMessage(NeoFsV2Acl.EACLTableImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Signature
          if (wireType === 2) { // Length-delimited
            message.Signature = reader.readMessage(NeoFsV2Refs.SignatureRFC6979Impl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SetExtendedACLRequest_BodyData {
    return {
      Eacl: this.Eacl,
      Signature: this.Signature
    };
  }

}

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

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

export interface SetExtendedACLResponse {
  Body?: SetExtendedACLResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class SetExtendedACLResponseImpl implements SetExtendedACLResponse {
  Body?: SetExtendedACLResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<SetExtendedACLResponse>) {
    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): SetExtendedACLResponseImpl {
    const reader = new BinaryReader(data);
    const message = new SetExtendedACLResponseImpl();

    // 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(SetExtendedACLResponse_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(): SetExtendedACLResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface SetExtendedACLResponse_Body {
}

export class SetExtendedACLResponse_BodyImpl implements SetExtendedACLResponse_Body {

  constructor(data?: Partial<SetExtendedACLResponse_Body>) {
  }

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

    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): SetExtendedACLResponse_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new SetExtendedACLResponse_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) {
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SetExtendedACLResponse_BodyData {
    return {
    };
  }

}

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

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

export interface GetExtendedACLRequest {
  Body?: GetExtendedACLRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class GetExtendedACLRequestImpl implements GetExtendedACLRequest {
  Body?: GetExtendedACLRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<GetExtendedACLRequest>) {
    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): GetExtendedACLRequestImpl {
    const reader = new BinaryReader(data);
    const message = new GetExtendedACLRequestImpl();

    // 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(GetExtendedACLRequest_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(): GetExtendedACLRequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface GetExtendedACLRequest_Body {
  ContainerId?: NeoFsV2Refs.ContainerID;
}

export class GetExtendedACLRequest_BodyImpl implements GetExtendedACLRequest_Body {
  ContainerId?: NeoFsV2Refs.ContainerID;

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

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

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

  static deserializeBinary(data: Uint8Array): GetExtendedACLRequest_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new GetExtendedACLRequest_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;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetExtendedACLRequest_BodyData {
    return {
      ContainerId: this.ContainerId
    };
  }

}

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

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

export interface GetExtendedACLResponse {
  Body?: GetExtendedACLResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class GetExtendedACLResponseImpl implements GetExtendedACLResponse {
  Body?: GetExtendedACLResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<GetExtendedACLResponse>) {
    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): GetExtendedACLResponseImpl {
    const reader = new BinaryReader(data);
    const message = new GetExtendedACLResponseImpl();

    // 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(GetExtendedACLResponse_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(): GetExtendedACLResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface GetExtendedACLResponse_Body {
  Eacl?: NeoFsV2Acl.EACLTable;
  Signature?: NeoFsV2Refs.SignatureRFC6979;
  SessionToken?: NeoFsV2Session.SessionToken;
}

export class GetExtendedACLResponse_BodyImpl implements GetExtendedACLResponse_Body {
  Eacl?: NeoFsV2Acl.EACLTable;
  Signature?: NeoFsV2Refs.SignatureRFC6979;
  SessionToken?: NeoFsV2Session.SessionToken;

  constructor(data?: Partial<GetExtendedACLResponse_Body>) {
    this.Eacl = data?.Eacl ?? undefined;
    this.Signature = data?.Signature ?? undefined;
    this.SessionToken = data?.SessionToken ?? undefined;
  }

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

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

  static deserializeBinary(data: Uint8Array): GetExtendedACLResponse_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new GetExtendedACLResponse_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: // Eacl
          if (wireType === 2) { // Length-delimited
            message.Eacl = reader.readMessage(NeoFsV2Acl.EACLTableImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Signature
          if (wireType === 2) { // Length-delimited
            message.Signature = reader.readMessage(NeoFsV2Refs.SignatureRFC6979Impl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // SessionToken
          if (wireType === 2) { // Length-delimited
            message.SessionToken = reader.readMessage(NeoFsV2Session.SessionTokenImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): GetExtendedACLResponse_BodyData {
    return {
      Eacl: this.Eacl,
      Signature: this.Signature,
      SessionToken: this.SessionToken
    };
  }

}

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

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

export interface AnnounceUsedSpaceRequest {
  Body?: AnnounceUsedSpaceRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;
}

export class AnnounceUsedSpaceRequestImpl implements AnnounceUsedSpaceRequest {
  Body?: AnnounceUsedSpaceRequest_Body;
  MetaHeader?: NeoFsV2Session.RequestMetaHeader;
  VerifyHeader?: NeoFsV2Session.RequestVerificationHeader;

  constructor(data?: Partial<AnnounceUsedSpaceRequest>) {
    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): AnnounceUsedSpaceRequestImpl {
    const reader = new BinaryReader(data);
    const message = new AnnounceUsedSpaceRequestImpl();

    // 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(AnnounceUsedSpaceRequest_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(): AnnounceUsedSpaceRequestData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface AnnounceUsedSpaceRequest_Body {
  Announcements: AnnounceUsedSpaceRequest_Body_Announcement[];
}

export class AnnounceUsedSpaceRequest_BodyImpl implements AnnounceUsedSpaceRequest_Body {
  Announcements!: AnnounceUsedSpaceRequest_Body_Announcement[];

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

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

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

  static deserializeBinary(data: Uint8Array): AnnounceUsedSpaceRequest_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new AnnounceUsedSpaceRequest_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: // Announcements
          if (wireType === 2) { // Length-delimited
            message.Announcements.push(reader.readMessage(AnnounceUsedSpaceRequest_Body_AnnouncementImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): AnnounceUsedSpaceRequest_BodyData {
    return {
      Announcements: this.Announcements
    };
  }

}

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

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

export interface AnnounceUsedSpaceRequest_Body_Announcement {
  Epoch: bigint;
  ContainerId?: NeoFsV2Refs.ContainerID;
  UsedSpace: bigint;
}

export class AnnounceUsedSpaceRequest_Body_AnnouncementImpl implements AnnounceUsedSpaceRequest_Body_Announcement {
  Epoch!: bigint;
  ContainerId?: NeoFsV2Refs.ContainerID;
  UsedSpace!: bigint;

  constructor(data?: Partial<AnnounceUsedSpaceRequest_Body_Announcement>) {
    this.Epoch = data?.Epoch ?? 0n;
    this.ContainerId = data?.ContainerId ?? undefined;
    this.UsedSpace = data?.UsedSpace ?? 0n;
  }

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

    if (this.Epoch !== 0n) {
      writer.writeUint64(1, this.Epoch);
    }
    if (this.ContainerId) {
      writer.writeMessage(2, this.ContainerId);
    }
    if (this.UsedSpace !== 0n) {
      writer.writeUint64(3, this.UsedSpace);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Epoch
          if (wireType === 0) { // Varint
            message.Epoch = reader.readUint64();
          } else if (wireType === 1) { // 64-bit
            message.Epoch = reader.readUint64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // ContainerId
          if (wireType === 2) { // Length-delimited
            message.ContainerId = reader.readMessage(NeoFsV2Refs.ContainerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // UsedSpace
          if (wireType === 0) { // Varint
            message.UsedSpace = reader.readUint64();
          } else if (wireType === 1) { // 64-bit
            message.UsedSpace = reader.readUint64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): AnnounceUsedSpaceRequest_Body_AnnouncementData {
    return {
      Epoch: this.Epoch,
      ContainerId: this.ContainerId,
      UsedSpace: this.UsedSpace
    };
  }

}

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

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

export interface AnnounceUsedSpaceResponse {
  Body?: AnnounceUsedSpaceResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;
}

export class AnnounceUsedSpaceResponseImpl implements AnnounceUsedSpaceResponse {
  Body?: AnnounceUsedSpaceResponse_Body;
  MetaHeader?: NeoFsV2Session.ResponseMetaHeader;
  VerifyHeader?: NeoFsV2Session.ResponseVerificationHeader;

  constructor(data?: Partial<AnnounceUsedSpaceResponse>) {
    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): AnnounceUsedSpaceResponseImpl {
    const reader = new BinaryReader(data);
    const message = new AnnounceUsedSpaceResponseImpl();

    // 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(AnnounceUsedSpaceResponse_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(): AnnounceUsedSpaceResponseData {
    return {
      Body: this.Body,
      MetaHeader: this.MetaHeader,
      VerifyHeader: this.VerifyHeader
    };
  }

}

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

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

export interface AnnounceUsedSpaceResponse_Body {
}

export class AnnounceUsedSpaceResponse_BodyImpl implements AnnounceUsedSpaceResponse_Body {

  constructor(data?: Partial<AnnounceUsedSpaceResponse_Body>) {
  }

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

    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): AnnounceUsedSpaceResponse_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new AnnounceUsedSpaceResponse_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) {
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): AnnounceUsedSpaceResponse_BodyData {
    return {
    };
  }

}

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

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

export interface SetAttributeRequest {
  Body?: SetAttributeRequest_Body;
  BodySignature?: NeoFsV2Refs.Signature;
}

export class SetAttributeRequestImpl implements SetAttributeRequest {
  Body?: SetAttributeRequest_Body;
  BodySignature?: NeoFsV2Refs.Signature;

  constructor(data?: Partial<SetAttributeRequest>) {
    this.Body = data?.Body ?? undefined;
    this.BodySignature = data?.BodySignature ?? undefined;
  }

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

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

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

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

    return message;
  }

  toObject(): SetAttributeRequestData {
    return {
      Body: this.Body,
      BodySignature: this.BodySignature
    };
  }

}

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

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

export interface SetAttributeRequest_Body {
  Parameters?: SetAttributeRequest_Body_Parameters;
  Signature?: NeoFsV2Refs.SignatureRFC6979;
  SessionToken?: NeoFsV2Session.SessionTokenV2;
  SessionTokenV1?: NeoFsV2Session.SessionToken;
}

export class SetAttributeRequest_BodyImpl implements SetAttributeRequest_Body {
  Parameters?: SetAttributeRequest_Body_Parameters;
  Signature?: NeoFsV2Refs.SignatureRFC6979;
  SessionToken?: NeoFsV2Session.SessionTokenV2;
  SessionTokenV1?: NeoFsV2Session.SessionToken;

  constructor(data?: Partial<SetAttributeRequest_Body>) {
    this.Parameters = data?.Parameters ?? undefined;
    this.Signature = data?.Signature ?? undefined;
    this.SessionToken = data?.SessionToken ?? undefined;
    this.SessionTokenV1 = data?.SessionTokenV1 ?? undefined;
  }

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

    if (this.Parameters) {
      writer.writeMessage(1, this.Parameters);
    }
    if (this.Signature) {
      writer.writeMessage(2, this.Signature);
    }
    if (this.SessionToken) {
      writer.writeMessage(3, this.SessionToken);
    }
    if (this.SessionTokenV1) {
      writer.writeMessage(4, this.SessionTokenV1);
    }
    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): SetAttributeRequest_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new SetAttributeRequest_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: // Parameters
          if (wireType === 2) { // Length-delimited
            message.Parameters = reader.readMessage(SetAttributeRequest_Body_ParametersImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Signature
          if (wireType === 2) { // Length-delimited
            message.Signature = reader.readMessage(NeoFsV2Refs.SignatureRFC6979Impl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // SessionToken
          if (wireType === 2) { // Length-delimited
            message.SessionToken = reader.readMessage(NeoFsV2Session.SessionTokenV2Impl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // SessionTokenV1
          if (wireType === 2) { // Length-delimited
            message.SessionTokenV1 = reader.readMessage(NeoFsV2Session.SessionTokenImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SetAttributeRequest_BodyData {
    return {
      Parameters: this.Parameters,
      Signature: this.Signature,
      SessionToken: this.SessionToken,
      SessionTokenV1: this.SessionTokenV1
    };
  }

}

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

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

export interface SetAttributeRequest_Body_Parameters {
  ContainerId?: NeoFsV2Refs.ContainerID;
  Attribute: string;
  Value: string;
  ValidUntil: bigint;
}

export class SetAttributeRequest_Body_ParametersImpl implements SetAttributeRequest_Body_Parameters {
  ContainerId?: NeoFsV2Refs.ContainerID;
  Attribute!: string;
  Value!: string;
  ValidUntil!: bigint;

  constructor(data?: Partial<SetAttributeRequest_Body_Parameters>) {
    this.ContainerId = data?.ContainerId ?? undefined;
    this.Attribute = data?.Attribute ?? "";
    this.Value = data?.Value ?? "";
    this.ValidUntil = data?.ValidUntil ?? 0n;
  }

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

    if (this.ContainerId) {
      writer.writeMessage(1, this.ContainerId);
    }
    if (this.Attribute !== "") {
      writer.writeString(2, this.Attribute);
    }
    if (this.Value !== "") {
      writer.writeString(3, this.Value);
    }
    if (this.ValidUntil !== 0n) {
      writer.writeUint64(4, this.ValidUntil);
    }
    return writer.getResultBuffer();
  }

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

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

    return message;
  }

  toObject(): SetAttributeRequest_Body_ParametersData {
    return {
      ContainerId: this.ContainerId,
      Attribute: this.Attribute,
      Value: this.Value,
      ValidUntil: this.ValidUntil
    };
  }

}

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

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

export interface SetAttributeResponse {
  Status?: NeoFsV2Status.Status;
}

export class SetAttributeResponseImpl implements SetAttributeResponse {
  Status?: NeoFsV2Status.Status;

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

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

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

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

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

    return message;
  }

  toObject(): SetAttributeResponseData {
    return {
      Status: this.Status
    };
  }

}

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

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

export interface RemoveAttributeRequest {
  Body?: RemoveAttributeRequest_Body;
  BodySignature?: NeoFsV2Refs.Signature;
}

export class RemoveAttributeRequestImpl implements RemoveAttributeRequest {
  Body?: RemoveAttributeRequest_Body;
  BodySignature?: NeoFsV2Refs.Signature;

  constructor(data?: Partial<RemoveAttributeRequest>) {
    this.Body = data?.Body ?? undefined;
    this.BodySignature = data?.BodySignature ?? undefined;
  }

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

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

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

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

    return message;
  }

  toObject(): RemoveAttributeRequestData {
    return {
      Body: this.Body,
      BodySignature: this.BodySignature
    };
  }

}

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

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

export interface RemoveAttributeRequest_Body {
  Parameters?: RemoveAttributeRequest_Body_Parameters;
  Signature?: NeoFsV2Refs.SignatureRFC6979;
  SessionToken?: NeoFsV2Session.SessionTokenV2;
  SessionTokenV1?: NeoFsV2Session.SessionToken;
}

export class RemoveAttributeRequest_BodyImpl implements RemoveAttributeRequest_Body {
  Parameters?: RemoveAttributeRequest_Body_Parameters;
  Signature?: NeoFsV2Refs.SignatureRFC6979;
  SessionToken?: NeoFsV2Session.SessionTokenV2;
  SessionTokenV1?: NeoFsV2Session.SessionToken;

  constructor(data?: Partial<RemoveAttributeRequest_Body>) {
    this.Parameters = data?.Parameters ?? undefined;
    this.Signature = data?.Signature ?? undefined;
    this.SessionToken = data?.SessionToken ?? undefined;
    this.SessionTokenV1 = data?.SessionTokenV1 ?? undefined;
  }

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

    if (this.Parameters) {
      writer.writeMessage(1, this.Parameters);
    }
    if (this.Signature) {
      writer.writeMessage(2, this.Signature);
    }
    if (this.SessionToken) {
      writer.writeMessage(3, this.SessionToken);
    }
    if (this.SessionTokenV1) {
      writer.writeMessage(4, this.SessionTokenV1);
    }
    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): RemoveAttributeRequest_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new RemoveAttributeRequest_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: // Parameters
          if (wireType === 2) { // Length-delimited
            message.Parameters = reader.readMessage(RemoveAttributeRequest_Body_ParametersImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Signature
          if (wireType === 2) { // Length-delimited
            message.Signature = reader.readMessage(NeoFsV2Refs.SignatureRFC6979Impl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // SessionToken
          if (wireType === 2) { // Length-delimited
            message.SessionToken = reader.readMessage(NeoFsV2Session.SessionTokenV2Impl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // SessionTokenV1
          if (wireType === 2) { // Length-delimited
            message.SessionTokenV1 = reader.readMessage(NeoFsV2Session.SessionTokenImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): RemoveAttributeRequest_BodyData {
    return {
      Parameters: this.Parameters,
      Signature: this.Signature,
      SessionToken: this.SessionToken,
      SessionTokenV1: this.SessionTokenV1
    };
  }

}

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

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

export interface RemoveAttributeRequest_Body_Parameters {
  ContainerId?: NeoFsV2Refs.ContainerID;
  Attribute: string;
  ValidUntil: bigint;
}

export class RemoveAttributeRequest_Body_ParametersImpl implements RemoveAttributeRequest_Body_Parameters {
  ContainerId?: NeoFsV2Refs.ContainerID;
  Attribute!: string;
  ValidUntil!: bigint;

  constructor(data?: Partial<RemoveAttributeRequest_Body_Parameters>) {
    this.ContainerId = data?.ContainerId ?? undefined;
    this.Attribute = data?.Attribute ?? "";
    this.ValidUntil = data?.ValidUntil ?? 0n;
  }

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

    if (this.ContainerId) {
      writer.writeMessage(1, this.ContainerId);
    }
    if (this.Attribute !== "") {
      writer.writeString(2, this.Attribute);
    }
    if (this.ValidUntil !== 0n) {
      writer.writeUint64(3, this.ValidUntil);
    }
    return writer.getResultBuffer();
  }

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

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

    return message;
  }

  toObject(): RemoveAttributeRequest_Body_ParametersData {
    return {
      ContainerId: this.ContainerId,
      Attribute: this.Attribute,
      ValidUntil: this.ValidUntil
    };
  }

}

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

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

export interface RemoveAttributeResponse {
  Status?: NeoFsV2Status.Status;
}

export class RemoveAttributeResponseImpl implements RemoveAttributeResponse {
  Status?: NeoFsV2Status.Status;

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

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

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

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

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

    return message;
  }

  toObject(): RemoveAttributeResponseData {
    return {
      Status: this.Status
    };
  }

}

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

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