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

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

type ChecksumType = NeoFsV2Refs.ChecksumType;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export namespace NeoFsV2Netmap {

export enum Operation {
  Operation_OPERATION_UNSPECIFIED = 0,
  Operation_EQ = 1,
  Operation_NE = 2,
  Operation_GT = 3,
  Operation_GE = 4,
  Operation_LT = 5,
  Operation_LE = 6,
  Operation_OR = 7,
  Operation_AND = 8,
}

export enum Clause {
  Clause_CLAUSE_UNSPECIFIED = 0,
  Clause_SAME = 1,
  Clause_DISTINCT = 2,
}

export interface Filter {
  Name: string;
  Key: string;
  Op: Operation;
  Value: string;
  Filters: Filter[];
}

export class FilterImpl implements Filter {
  Name!: string;
  Key!: string;
  Op!: Operation;
  Value!: string;
  Filters!: Filter[];

  constructor(data?: Partial<Filter>) {
    this.Name = data?.Name ?? "";
    this.Key = data?.Key ?? "";
    this.Op = data?.Op ?? 0;
    this.Value = data?.Value ?? "";
    this.Filters = data?.Filters ?? [];
  }

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

    if (this.Name !== "") {
      writer.writeString(1, this.Name);
    }
    if (this.Key !== "") {
      writer.writeString(2, this.Key);
    }
    if (this.Op !== 0) {
      writer.writeEnum(3, this.Op);
    }
    if (this.Value !== "") {
      writer.writeString(4, this.Value);
    }
    for (const item of this.Filters) {
      writer.writeMessage(5, item);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Name
          if (wireType === 2) { // Length-delimited
            message.Name = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Key
          if (wireType === 2) { // Length-delimited
            message.Key = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Op
          if (wireType === 0) { // Varint
            message.Op = reader.readEnum();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // Value
          if (wireType === 2) { // Length-delimited
            message.Value = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 5: // Filters
          if (wireType === 2) { // Length-delimited
            message.Filters.push(reader.readMessage(FilterImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): FilterData {
    return {
      Name: this.Name,
      Key: this.Key,
      Op: this.Op,
      Value: this.Value,
      Filters: this.Filters
    };
  }

}

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

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

export interface Selector {
  Name: string;
  Count: number;
  Clause: Clause;
  Attribute: string;
  Filter: string;
}

export class SelectorImpl implements Selector {
  Name!: string;
  Count!: number;
  Clause!: Clause;
  Attribute!: string;
  Filter!: string;

  constructor(data?: Partial<Selector>) {
    this.Name = data?.Name ?? "";
    this.Count = data?.Count ?? 0;
    this.Clause = data?.Clause ?? 0;
    this.Attribute = data?.Attribute ?? "";
    this.Filter = data?.Filter ?? "";
  }

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

    if (this.Name !== "") {
      writer.writeString(1, this.Name);
    }
    if (this.Count !== 0) {
      writer.writeUint32(2, this.Count);
    }
    if (this.Clause !== 0) {
      writer.writeEnum(3, this.Clause);
    }
    if (this.Attribute !== "") {
      writer.writeString(4, this.Attribute);
    }
    if (this.Filter !== "") {
      writer.writeString(5, this.Filter);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Name
          if (wireType === 2) { // Length-delimited
            message.Name = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Count
          if (wireType === 0) { // Varint
            message.Count = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.Count = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Clause
          if (wireType === 0) { // Varint
            message.Clause = reader.readEnum();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // Attribute
          if (wireType === 2) { // Length-delimited
            message.Attribute = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 5: // Filter
          if (wireType === 2) { // Length-delimited
            message.Filter = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SelectorData {
    return {
      Name: this.Name,
      Count: this.Count,
      Clause: this.Clause,
      Attribute: this.Attribute,
      Filter: this.Filter
    };
  }

}

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

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

export interface Replica {
  Count: number;
  Selector: string;
}

export class ReplicaImpl implements Replica {
  Count!: number;
  Selector!: string;

  constructor(data?: Partial<Replica>) {
    this.Count = data?.Count ?? 0;
    this.Selector = data?.Selector ?? "";
  }

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

    if (this.Count !== 0) {
      writer.writeUint32(1, this.Count);
    }
    if (this.Selector !== "") {
      writer.writeString(2, this.Selector);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Count
          if (wireType === 0) { // Varint
            message.Count = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.Count = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Selector
          if (wireType === 2) { // Length-delimited
            message.Selector = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): ReplicaData {
    return {
      Count: this.Count,
      Selector: this.Selector
    };
  }

}

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

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

export interface PlacementPolicy {
  Replicas: Replica[];
  ContainerBackupFactor: number;
  Selectors: Selector[];
  Filters: Filter[];
  SubnetId?: NeoFsV2Refs.SubnetID;
  EcRules: PlacementPolicy_ECRule[];
  Initial?: PlacementPolicy_Initial;
}

export class PlacementPolicyImpl implements PlacementPolicy {
  Replicas!: Replica[];
  ContainerBackupFactor!: number;
  Selectors!: Selector[];
  Filters!: Filter[];
  SubnetId?: NeoFsV2Refs.SubnetID;
  EcRules!: PlacementPolicy_ECRule[];
  Initial?: PlacementPolicy_Initial;

  constructor(data?: Partial<PlacementPolicy>) {
    this.Replicas = data?.Replicas ?? [];
    this.ContainerBackupFactor = data?.ContainerBackupFactor ?? 0;
    this.Selectors = data?.Selectors ?? [];
    this.Filters = data?.Filters ?? [];
    this.SubnetId = data?.SubnetId ?? undefined;
    this.EcRules = data?.EcRules ?? [];
    this.Initial = data?.Initial ?? undefined;
  }

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

    for (const item of this.Replicas) {
      writer.writeMessage(1, item);
    }
    if (this.ContainerBackupFactor !== 0) {
      writer.writeUint32(2, this.ContainerBackupFactor);
    }
    for (const item of this.Selectors) {
      writer.writeMessage(3, item);
    }
    for (const item of this.Filters) {
      writer.writeMessage(4, item);
    }
    if (this.SubnetId) {
      writer.writeMessage(5, this.SubnetId);
    }
    for (const item of this.EcRules) {
      writer.writeMessage(6, item);
    }
    if (this.Initial) {
      writer.writeMessage(7, this.Initial);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Replicas
          if (wireType === 2) { // Length-delimited
            message.Replicas.push(reader.readMessage(ReplicaImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // ContainerBackupFactor
          if (wireType === 0) { // Varint
            message.ContainerBackupFactor = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.ContainerBackupFactor = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Selectors
          if (wireType === 2) { // Length-delimited
            message.Selectors.push(reader.readMessage(SelectorImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // Filters
          if (wireType === 2) { // Length-delimited
            message.Filters.push(reader.readMessage(FilterImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 5: // SubnetId
          if (wireType === 2) { // Length-delimited
            message.SubnetId = reader.readMessage(NeoFsV2Refs.SubnetIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 6: // EcRules
          if (wireType === 2) { // Length-delimited
            message.EcRules.push(reader.readMessage(PlacementPolicy_ECRuleImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 7: // Initial
          if (wireType === 2) { // Length-delimited
            message.Initial = reader.readMessage(PlacementPolicy_InitialImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): PlacementPolicyData {
    return {
      Replicas: this.Replicas,
      ContainerBackupFactor: this.ContainerBackupFactor,
      Selectors: this.Selectors,
      Filters: this.Filters,
      SubnetId: this.SubnetId,
      EcRules: this.EcRules,
      Initial: this.Initial
    };
  }

}

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

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

export interface PlacementPolicy_ECRule {
  DataPartNum: number;
  ParityPartNum: number;
  Selector: string;
}

export class PlacementPolicy_ECRuleImpl implements PlacementPolicy_ECRule {
  DataPartNum!: number;
  ParityPartNum!: number;
  Selector!: string;

  constructor(data?: Partial<PlacementPolicy_ECRule>) {
    this.DataPartNum = data?.DataPartNum ?? 0;
    this.ParityPartNum = data?.ParityPartNum ?? 0;
    this.Selector = data?.Selector ?? "";
  }

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

    if (this.DataPartNum !== 0) {
      writer.writeUint32(1, this.DataPartNum);
    }
    if (this.ParityPartNum !== 0) {
      writer.writeUint32(2, this.ParityPartNum);
    }
    if (this.Selector !== "") {
      writer.writeString(3, this.Selector);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // DataPartNum
          if (wireType === 0) { // Varint
            message.DataPartNum = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.DataPartNum = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // ParityPartNum
          if (wireType === 0) { // Varint
            message.ParityPartNum = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.ParityPartNum = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Selector
          if (wireType === 2) { // Length-delimited
            message.Selector = reader.readString();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): PlacementPolicy_ECRuleData {
    return {
      DataPartNum: this.DataPartNum,
      ParityPartNum: this.ParityPartNum,
      Selector: this.Selector
    };
  }

}

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

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

export interface PlacementPolicy_Initial {
  ReplicaLimits: number[];
  MaxReplicas: number;
  PreferLocal: boolean;
}

export class PlacementPolicy_InitialImpl implements PlacementPolicy_Initial {
  ReplicaLimits!: number[];
  MaxReplicas!: number;
  PreferLocal!: boolean;

  constructor(data?: Partial<PlacementPolicy_Initial>) {
    this.ReplicaLimits = data?.ReplicaLimits ?? [];
    this.MaxReplicas = data?.MaxReplicas ?? 0;
    this.PreferLocal = data?.PreferLocal ?? false;
  }

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

    for (const item of this.ReplicaLimits) {
      writer.writeUint32(1, item);
    }
    if (this.MaxReplicas !== 0) {
      writer.writeUint32(2, this.MaxReplicas);
    }
    if (this.PreferLocal !== false) {
      writer.writeBool(3, this.PreferLocal);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // ReplicaLimits
          if (wireType === 2) { // Length-delimited (packed)
            const length = reader.readVarint();
            const endPos = reader.position + length;
            while (reader.position < endPos) {
              message.ReplicaLimits.push(reader.readUint32());
            }
          } else {
            // Non-packed encoding - single item
            if (wireType === 0) { message.ReplicaLimits.push(reader.readUint32()); }
          }
          break;
        case 2: // MaxReplicas
          if (wireType === 0) { // Varint
            message.MaxReplicas = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.MaxReplicas = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // PreferLocal
          if (wireType === 0) { // Varint
            message.PreferLocal = reader.readBool();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): PlacementPolicy_InitialData {
    return {
      ReplicaLimits: this.ReplicaLimits,
      MaxReplicas: this.MaxReplicas,
      PreferLocal: this.PreferLocal
    };
  }

}

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

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

export interface NodeInfo {
  PublicKey: Uint8Array;
  Addresses: string[];
  Attributes: NodeInfo_Attribute[];
  State: NodeInfo_State;
}

export class NodeInfoImpl implements NodeInfo {
  PublicKey!: Uint8Array;
  Addresses!: string[];
  Attributes!: NodeInfo_Attribute[];
  State!: NodeInfo_State;

  constructor(data?: Partial<NodeInfo>) {
    this.PublicKey = data?.PublicKey ?? new Uint8Array(0);
    this.Addresses = data?.Addresses ?? [];
    this.Attributes = data?.Attributes ?? [];
    this.State = data?.State ?? 0;
  }

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

    if (this.PublicKey.length > 0) {
      writer.writeBytes(1, this.PublicKey);
    }
    for (const item of this.Addresses) {
      writer.writeString(2, item);
    }
    for (const item of this.Attributes) {
      writer.writeMessage(3, item);
    }
    if (this.State !== 0) {
      writer.writeEnum(4, this.State);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // PublicKey
          if (wireType === 2) { // Length-delimited
            message.PublicKey = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Addresses
          if (wireType === 2) { // Length-delimited
            message.Addresses.push(reader.readString());
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Attributes
          if (wireType === 2) { // Length-delimited
            message.Attributes.push(reader.readMessage(NodeInfo_AttributeImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // State
          if (wireType === 0) { // Varint
            message.State = reader.readEnum();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): NodeInfoData {
    return {
      PublicKey: this.PublicKey,
      Addresses: this.Addresses,
      Attributes: this.Attributes,
      State: this.State
    };
  }

}

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

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

export interface NodeInfo_Attribute {
  Key: string;
  Value: string;
  Parents: string[];
}

export class NodeInfo_AttributeImpl implements NodeInfo_Attribute {
  Key!: string;
  Value!: string;
  Parents!: string[];

  constructor(data?: Partial<NodeInfo_Attribute>) {
    this.Key = data?.Key ?? "";
    this.Value = data?.Value ?? "";
    this.Parents = data?.Parents ?? [];
  }

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

    if (this.Key !== "") {
      writer.writeString(1, this.Key);
    }
    if (this.Value !== "") {
      writer.writeString(2, this.Value);
    }
    for (const item of this.Parents) {
      writer.writeString(3, item);
    }
    return writer.getResultBuffer();
  }

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

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

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

    return message;
  }

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

}

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

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

export enum NodeInfo_State {
  NodeInfo_UNSPECIFIED = 0,
  NodeInfo_ONLINE = 1,
  NodeInfo_OFFLINE = 2,
  NodeInfo_MAINTENANCE = 3,
}

export interface Netmap {
  Epoch: bigint;
  Nodes: NodeInfo[];
}

export class NetmapImpl implements Netmap {
  Epoch!: bigint;
  Nodes!: NodeInfo[];

  constructor(data?: Partial<Netmap>) {
    this.Epoch = data?.Epoch ?? 0n;
    this.Nodes = data?.Nodes ?? [];
  }

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

    if (this.Epoch !== 0n) {
      writer.writeUint64(1, this.Epoch);
    }
    for (const item of this.Nodes) {
      writer.writeMessage(2, item);
    }
    return writer.getResultBuffer();
  }

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

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

    return message;
  }

  toObject(): NetmapData {
    return {
      Epoch: this.Epoch,
      Nodes: this.Nodes
    };
  }

}

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

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

export interface NetworkConfig {
  Parameters: NetworkConfig_Parameter[];
}

export class NetworkConfigImpl implements NetworkConfig {
  Parameters!: NetworkConfig_Parameter[];

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

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

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

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

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

    return message;
  }

  toObject(): NetworkConfigData {
    return {
      Parameters: this.Parameters
    };
  }

}

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

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

export interface NetworkConfig_Parameter {
  Key: Uint8Array;
  Value: Uint8Array;
}

export class NetworkConfig_ParameterImpl implements NetworkConfig_Parameter {
  Key!: Uint8Array;
  Value!: Uint8Array;

  constructor(data?: Partial<NetworkConfig_Parameter>) {
    this.Key = data?.Key ?? new Uint8Array(0);
    this.Value = data?.Value ?? new Uint8Array(0);
  }

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

    if (this.Key.length > 0) {
      writer.writeBytes(1, this.Key);
    }
    if (this.Value.length > 0) {
      writer.writeBytes(2, this.Value);
    }
    return writer.getResultBuffer();
  }

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

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

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

    return message;
  }

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

}

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

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

export interface NetworkInfo {
  CurrentEpoch: bigint;
  MagicNumber: bigint;
  MsPerBlock: bigint;
  NetworkConfig?: NetworkConfig;
}

export class NetworkInfoImpl implements NetworkInfo {
  CurrentEpoch!: bigint;
  MagicNumber!: bigint;
  MsPerBlock!: bigint;
  NetworkConfig?: NetworkConfig;

  constructor(data?: Partial<NetworkInfo>) {
    this.CurrentEpoch = data?.CurrentEpoch ?? 0n;
    this.MagicNumber = data?.MagicNumber ?? 0n;
    this.MsPerBlock = data?.MsPerBlock ?? 0n;
    this.NetworkConfig = data?.NetworkConfig ?? undefined;
  }

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

    if (this.CurrentEpoch !== 0n) {
      writer.writeUint64(1, this.CurrentEpoch);
    }
    if (this.MagicNumber !== 0n) {
      writer.writeUint64(2, this.MagicNumber);
    }
    if (this.MsPerBlock !== 0n) {
      writer.writeInt64(3, this.MsPerBlock);
    }
    if (this.NetworkConfig) {
      writer.writeMessage(4, this.NetworkConfig);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // CurrentEpoch
          if (wireType === 0) { // Varint
            message.CurrentEpoch = reader.readUint64();
          } else if (wireType === 1) { // 64-bit
            message.CurrentEpoch = reader.readUint64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // MagicNumber
          if (wireType === 0) { // Varint
            message.MagicNumber = reader.readUint64();
          } else if (wireType === 1) { // 64-bit
            message.MagicNumber = reader.readUint64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // MsPerBlock
          if (wireType === 0) { // Varint
            message.MsPerBlock = reader.readInt64();
          } else if (wireType === 1) { // 64-bit
            message.MsPerBlock = reader.readInt64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // NetworkConfig
          if (wireType === 2) { // Length-delimited
            message.NetworkConfig = reader.readMessage(NetworkConfigImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): NetworkInfoData {
    return {
      CurrentEpoch: this.CurrentEpoch,
      MagicNumber: this.MagicNumber,
      MsPerBlock: this.MsPerBlock,
      NetworkConfig: this.NetworkConfig
    };
  }

}

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

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

} // namespace NeoFsV2Netmap