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

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 namespace NeoFsV2Session {

export enum Verb {
  Verb_VERB_UNSPECIFIED = 0,
  Verb_OBJECT_PUT = 1,
  Verb_OBJECT_GET = 2,
  Verb_OBJECT_HEAD = 3,
  Verb_OBJECT_SEARCH = 4,
  Verb_OBJECT_DELETE = 5,
  Verb_OBJECT_RANGE = 6,
  Verb_OBJECT_RANGEHASH = 7,
  Verb_CONTAINER_PUT = 8,
  Verb_CONTAINER_DELETE = 9,
  Verb_CONTAINER_SETEACL = 10,
  Verb_CONTAINER_SETATTRIBUTE = 11,
  Verb_CONTAINER_REMOVEATTRIBUTE = 12,
}

export interface ObjectSessionContext {
  Verb: ObjectSessionContext_Verb;
  Target?: ObjectSessionContext_Target;
}

export class ObjectSessionContextImpl implements ObjectSessionContext {
  Verb!: ObjectSessionContext_Verb;
  Target?: ObjectSessionContext_Target;

  constructor(data?: Partial<ObjectSessionContext>) {
    this.Verb = data?.Verb ?? 0;
    this.Target = data?.Target ?? undefined;
  }

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

    if (this.Verb !== 0) {
      writer.writeEnum(1, this.Verb);
    }
    if (this.Target) {
      writer.writeMessage(2, this.Target);
    }
    return writer.getResultBuffer();
  }

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

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

    return message;
  }

  toObject(): ObjectSessionContextData {
    return {
      Verb: this.Verb,
      Target: this.Target
    };
  }

}

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

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

export interface ObjectSessionContext_Target {
  Container?: NeoFsV2Refs.ContainerID;
  Objects: NeoFsV2Refs.ObjectID[];
}

export class ObjectSessionContext_TargetImpl implements ObjectSessionContext_Target {
  Container?: NeoFsV2Refs.ContainerID;
  Objects!: NeoFsV2Refs.ObjectID[];

  constructor(data?: Partial<ObjectSessionContext_Target>) {
    this.Container = data?.Container ?? undefined;
    this.Objects = data?.Objects ?? [];
  }

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

    if (this.Container) {
      writer.writeMessage(1, this.Container);
    }
    for (const item of this.Objects) {
      writer.writeMessage(2, item);
    }
    return writer.getResultBuffer();
  }

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

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

    return message;
  }

  toObject(): ObjectSessionContext_TargetData {
    return {
      Container: this.Container,
      Objects: this.Objects
    };
  }

}

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

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

export enum ObjectSessionContext_Verb {
  ObjectSessionContext_VERB_UNSPECIFIED = 0,
  ObjectSessionContext_PUT = 1,
  ObjectSessionContext_GET = 2,
  ObjectSessionContext_HEAD = 3,
  ObjectSessionContext_SEARCH = 4,
  ObjectSessionContext_DELETE = 5,
  ObjectSessionContext_RANGE = 6,
  ObjectSessionContext_RANGEHASH = 7,
}

export interface ContainerSessionContext {
  Verb: ContainerSessionContext_Verb;
  Wildcard: boolean;
  ContainerId?: NeoFsV2Refs.ContainerID;
}

export class ContainerSessionContextImpl implements ContainerSessionContext {
  Verb!: ContainerSessionContext_Verb;
  Wildcard!: boolean;
  ContainerId?: NeoFsV2Refs.ContainerID;

  constructor(data?: Partial<ContainerSessionContext>) {
    this.Verb = data?.Verb ?? 0;
    this.Wildcard = data?.Wildcard ?? false;
    this.ContainerId = data?.ContainerId ?? undefined;
  }

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

    if (this.Verb !== 0) {
      writer.writeEnum(1, this.Verb);
    }
    if (this.Wildcard !== false) {
      writer.writeBool(2, this.Wildcard);
    }
    if (this.ContainerId) {
      writer.writeMessage(3, this.ContainerId);
    }
    return writer.getResultBuffer();
  }

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

    // 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: // Verb
          if (wireType === 0) { // Varint
            message.Verb = reader.readEnum();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Wildcard
          if (wireType === 0) { // Varint
            message.Wildcard = reader.readBool();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // 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(): ContainerSessionContextData {
    return {
      Verb: this.Verb,
      Wildcard: this.Wildcard,
      ContainerId: this.ContainerId
    };
  }

}

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

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

export enum ContainerSessionContext_Verb {
  ContainerSessionContext_VERB_UNSPECIFIED = 0,
  ContainerSessionContext_PUT = 1,
  ContainerSessionContext_DELETE = 2,
  ContainerSessionContext_SETEACL = 3,
  ContainerSessionContext_SETATTRIBUTE = 4,
  ContainerSessionContext_REMOVEATTRIBUTE = 5,
}

export interface SessionToken {
  Body?: SessionToken_Body;
  Signature?: NeoFsV2Refs.Signature;
}

export class SessionTokenImpl implements SessionToken {
  Body?: SessionToken_Body;
  Signature?: NeoFsV2Refs.Signature;

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

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

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

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

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

    return message;
  }

  toObject(): SessionTokenData {
    return {
      Body: this.Body,
      Signature: this.Signature
    };
  }

}

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

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

export interface SessionToken_Body {
  Id: Uint8Array;
  OwnerId?: NeoFsV2Refs.OwnerID;
  Lifetime?: SessionToken_Body_TokenLifetime;
  SessionKey: Uint8Array;
  Object?: ObjectSessionContext;
  Container?: ContainerSessionContext;
}

export class SessionToken_BodyImpl implements SessionToken_Body {
  Id!: Uint8Array;
  OwnerId?: NeoFsV2Refs.OwnerID;
  Lifetime?: SessionToken_Body_TokenLifetime;
  SessionKey!: Uint8Array;
  Object?: ObjectSessionContext;
  Container?: ContainerSessionContext;

  constructor(data?: Partial<SessionToken_Body>) {
    this.Id = data?.Id ?? new Uint8Array(0);
    this.OwnerId = data?.OwnerId ?? undefined;
    this.Lifetime = data?.Lifetime ?? undefined;
    this.SessionKey = data?.SessionKey ?? new Uint8Array(0);
    this.Object = data?.Object ?? undefined;
    this.Container = data?.Container ?? undefined;
  }

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

    if (this.Id.length > 0) {
      writer.writeBytes(1, this.Id);
    }
    if (this.OwnerId) {
      writer.writeMessage(2, this.OwnerId);
    }
    if (this.Lifetime) {
      writer.writeMessage(3, this.Lifetime);
    }
    if (this.SessionKey.length > 0) {
      writer.writeBytes(4, this.SessionKey);
    }
    if (this.Object) {
      writer.writeMessage(5, this.Object);
    }
    if (this.Container) {
      writer.writeMessage(6, this.Container);
    }
    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): SessionToken_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new SessionToken_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: // Id
          if (wireType === 2) { // Length-delimited
            message.Id = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // OwnerId
          if (wireType === 2) { // Length-delimited
            message.OwnerId = reader.readMessage(NeoFsV2Refs.OwnerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Lifetime
          if (wireType === 2) { // Length-delimited
            message.Lifetime = reader.readMessage(SessionToken_Body_TokenLifetimeImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // SessionKey
          if (wireType === 2) { // Length-delimited
            message.SessionKey = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 5: // Object
          if (wireType === 2) { // Length-delimited
            message.Object = reader.readMessage(ObjectSessionContextImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 6: // Container
          if (wireType === 2) { // Length-delimited
            message.Container = reader.readMessage(ContainerSessionContextImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SessionToken_BodyData {
    return {
      Id: this.Id,
      OwnerId: this.OwnerId,
      Lifetime: this.Lifetime,
      SessionKey: this.SessionKey,
      Object: this.Object,
      Container: this.Container
    };
  }

}

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

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

export interface SessionToken_Body_TokenLifetime {
  Exp: bigint;
  Nbf: bigint;
  Iat: bigint;
}

export class SessionToken_Body_TokenLifetimeImpl implements SessionToken_Body_TokenLifetime {
  Exp!: bigint;
  Nbf!: bigint;
  Iat!: bigint;

  constructor(data?: Partial<SessionToken_Body_TokenLifetime>) {
    this.Exp = data?.Exp ?? 0n;
    this.Nbf = data?.Nbf ?? 0n;
    this.Iat = data?.Iat ?? 0n;
  }

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

    if (this.Exp !== 0n) {
      writer.writeUint64(1, this.Exp);
    }
    if (this.Nbf !== 0n) {
      writer.writeUint64(2, this.Nbf);
    }
    if (this.Iat !== 0n) {
      writer.writeUint64(3, this.Iat);
    }
    return writer.getResultBuffer();
  }

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

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

    return message;
  }

  toObject(): SessionToken_Body_TokenLifetimeData {
    return {
      Exp: this.Exp,
      Nbf: this.Nbf,
      Iat: this.Iat
    };
  }

}

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

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

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

export class XHeaderImpl implements XHeader {
  Key!: string;
  Value!: string;

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

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

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

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

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

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

    return message;
  }

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

}

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

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

export interface RequestMetaHeader {
  Version?: NeoFsV2Refs.Version;
  Epoch: bigint;
  Ttl: number;
  XHeaders: XHeader[];
  SessionToken?: SessionToken;
  SessionTokenV2?: SessionTokenV2;
  BearerToken?: NeoFsV2Acl.BearerToken;
  Origin?: RequestMetaHeader;
  MagicNumber: bigint;
}

export class RequestMetaHeaderImpl implements RequestMetaHeader {
  Version?: NeoFsV2Refs.Version;
  Epoch!: bigint;
  Ttl!: number;
  XHeaders!: XHeader[];
  SessionToken?: SessionToken;
  SessionTokenV2?: SessionTokenV2;
  BearerToken?: NeoFsV2Acl.BearerToken;
  Origin?: RequestMetaHeader;
  MagicNumber!: bigint;

  constructor(data?: Partial<RequestMetaHeader>) {
    this.Version = data?.Version ?? undefined;
    this.Epoch = data?.Epoch ?? 0n;
    this.Ttl = data?.Ttl ?? 0;
    this.XHeaders = data?.XHeaders ?? [];
    this.SessionToken = data?.SessionToken ?? undefined;
    this.SessionTokenV2 = data?.SessionTokenV2 ?? undefined;
    this.BearerToken = data?.BearerToken ?? undefined;
    this.Origin = data?.Origin ?? undefined;
    this.MagicNumber = data?.MagicNumber ?? 0n;
  }

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

    if (this.Version) {
      writer.writeMessage(1, this.Version);
    }
    if (this.Epoch !== 0n) {
      writer.writeUint64(2, this.Epoch);
    }
    if (this.Ttl !== 0) {
      writer.writeUint32(3, this.Ttl);
    }
    for (const item of this.XHeaders) {
      writer.writeMessage(4, item);
    }
    if (this.SessionToken) {
      writer.writeMessage(5, this.SessionToken);
    }
    if (this.SessionTokenV2) {
      writer.writeMessage(9, this.SessionTokenV2);
    }
    if (this.BearerToken) {
      writer.writeMessage(6, this.BearerToken);
    }
    if (this.Origin) {
      writer.writeMessage(7, this.Origin);
    }
    if (this.MagicNumber !== 0n) {
      writer.writeUint64(8, this.MagicNumber);
    }
    return writer.getResultBuffer();
  }

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

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

      switch (fieldNumber) {
        case 1: // Version
          if (wireType === 2) { // Length-delimited
            message.Version = reader.readMessage(NeoFsV2Refs.VersionImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // 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 3: // Ttl
          if (wireType === 0) { // Varint
            message.Ttl = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.Ttl = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // XHeaders
          if (wireType === 2) { // Length-delimited
            message.XHeaders.push(reader.readMessage(XHeaderImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 5: // SessionToken
          if (wireType === 2) { // Length-delimited
            message.SessionToken = reader.readMessage(SessionTokenImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 9: // SessionTokenV2
          if (wireType === 2) { // Length-delimited
            message.SessionTokenV2 = reader.readMessage(SessionTokenV2Impl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 6: // BearerToken
          if (wireType === 2) { // Length-delimited
            message.BearerToken = reader.readMessage(NeoFsV2Acl.BearerTokenImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 7: // Origin
          if (wireType === 2) { // Length-delimited
            message.Origin = reader.readMessage(RequestMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 8: // MagicNumber
          if (wireType === 0) { // Varint
            message.MagicNumber = reader.readUint64();
          } else if (wireType === 1) { // 64-bit
            message.MagicNumber = reader.readUint64Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): RequestMetaHeaderData {
    return {
      Version: this.Version,
      Epoch: this.Epoch,
      Ttl: this.Ttl,
      XHeaders: this.XHeaders,
      SessionToken: this.SessionToken,
      SessionTokenV2: this.SessionTokenV2,
      BearerToken: this.BearerToken,
      Origin: this.Origin,
      MagicNumber: this.MagicNumber
    };
  }

}

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

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

export interface ResponseMetaHeader {
  Version?: NeoFsV2Refs.Version;
  Epoch: bigint;
  Ttl: number;
  XHeaders: XHeader[];
  Origin?: ResponseMetaHeader;
  Status?: NeoFsV2Status.Status;
}

export class ResponseMetaHeaderImpl implements ResponseMetaHeader {
  Version?: NeoFsV2Refs.Version;
  Epoch!: bigint;
  Ttl!: number;
  XHeaders!: XHeader[];
  Origin?: ResponseMetaHeader;
  Status?: NeoFsV2Status.Status;

  constructor(data?: Partial<ResponseMetaHeader>) {
    this.Version = data?.Version ?? undefined;
    this.Epoch = data?.Epoch ?? 0n;
    this.Ttl = data?.Ttl ?? 0;
    this.XHeaders = data?.XHeaders ?? [];
    this.Origin = data?.Origin ?? undefined;
    this.Status = data?.Status ?? undefined;
  }

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

    if (this.Version) {
      writer.writeMessage(1, this.Version);
    }
    if (this.Epoch !== 0n) {
      writer.writeUint64(2, this.Epoch);
    }
    if (this.Ttl !== 0) {
      writer.writeUint32(3, this.Ttl);
    }
    for (const item of this.XHeaders) {
      writer.writeMessage(4, item);
    }
    if (this.Origin) {
      writer.writeMessage(5, this.Origin);
    }
    if (this.Status) {
      writer.writeMessage(6, this.Status);
    }
    return writer.getResultBuffer();
  }

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

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

      switch (fieldNumber) {
        case 1: // Version
          if (wireType === 2) { // Length-delimited
            message.Version = reader.readMessage(NeoFsV2Refs.VersionImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // 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 3: // Ttl
          if (wireType === 0) { // Varint
            message.Ttl = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.Ttl = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // XHeaders
          if (wireType === 2) { // Length-delimited
            message.XHeaders.push(reader.readMessage(XHeaderImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 5: // Origin
          if (wireType === 2) { // Length-delimited
            message.Origin = reader.readMessage(ResponseMetaHeaderImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 6: // 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(): ResponseMetaHeaderData {
    return {
      Version: this.Version,
      Epoch: this.Epoch,
      Ttl: this.Ttl,
      XHeaders: this.XHeaders,
      Origin: this.Origin,
      Status: this.Status
    };
  }

}

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

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

export interface RequestVerificationHeader {
  BodySignature?: NeoFsV2Refs.Signature;
  MetaSignature?: NeoFsV2Refs.Signature;
  OriginSignature?: NeoFsV2Refs.Signature;
  Origin?: RequestVerificationHeader;
}

export class RequestVerificationHeaderImpl implements RequestVerificationHeader {
  BodySignature?: NeoFsV2Refs.Signature;
  MetaSignature?: NeoFsV2Refs.Signature;
  OriginSignature?: NeoFsV2Refs.Signature;
  Origin?: RequestVerificationHeader;

  constructor(data?: Partial<RequestVerificationHeader>) {
    this.BodySignature = data?.BodySignature ?? undefined;
    this.MetaSignature = data?.MetaSignature ?? undefined;
    this.OriginSignature = data?.OriginSignature ?? undefined;
    this.Origin = data?.Origin ?? undefined;
  }

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

    if (this.BodySignature) {
      writer.writeMessage(1, this.BodySignature);
    }
    if (this.MetaSignature) {
      writer.writeMessage(2, this.MetaSignature);
    }
    if (this.OriginSignature) {
      writer.writeMessage(3, this.OriginSignature);
    }
    if (this.Origin) {
      writer.writeMessage(4, this.Origin);
    }
    return writer.getResultBuffer();
  }

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

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

    return message;
  }

  toObject(): RequestVerificationHeaderData {
    return {
      BodySignature: this.BodySignature,
      MetaSignature: this.MetaSignature,
      OriginSignature: this.OriginSignature,
      Origin: this.Origin
    };
  }

}

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

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

export interface ResponseVerificationHeader {
  BodySignature?: NeoFsV2Refs.Signature;
  MetaSignature?: NeoFsV2Refs.Signature;
  OriginSignature?: NeoFsV2Refs.Signature;
  Origin?: ResponseVerificationHeader;
}

export class ResponseVerificationHeaderImpl implements ResponseVerificationHeader {
  BodySignature?: NeoFsV2Refs.Signature;
  MetaSignature?: NeoFsV2Refs.Signature;
  OriginSignature?: NeoFsV2Refs.Signature;
  Origin?: ResponseVerificationHeader;

  constructor(data?: Partial<ResponseVerificationHeader>) {
    this.BodySignature = data?.BodySignature ?? undefined;
    this.MetaSignature = data?.MetaSignature ?? undefined;
    this.OriginSignature = data?.OriginSignature ?? undefined;
    this.Origin = data?.Origin ?? undefined;
  }

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

    if (this.BodySignature) {
      writer.writeMessage(1, this.BodySignature);
    }
    if (this.MetaSignature) {
      writer.writeMessage(2, this.MetaSignature);
    }
    if (this.OriginSignature) {
      writer.writeMessage(3, this.OriginSignature);
    }
    if (this.Origin) {
      writer.writeMessage(4, this.Origin);
    }
    return writer.getResultBuffer();
  }

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

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

    return message;
  }

  toObject(): ResponseVerificationHeaderData {
    return {
      BodySignature: this.BodySignature,
      MetaSignature: this.MetaSignature,
      OriginSignature: this.OriginSignature,
      Origin: this.Origin
    };
  }

}

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

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

export interface Target {
  OwnerId?: NeoFsV2Refs.OwnerID;
  NnsName: string;
}

export class TargetImpl implements Target {
  OwnerId?: NeoFsV2Refs.OwnerID;
  NnsName!: string;

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

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

    if (this.OwnerId) {
      writer.writeMessage(1, this.OwnerId);
    }
    if (this.NnsName !== "") {
      writer.writeString(2, this.NnsName);
    }
    return writer.getResultBuffer();
  }

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

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

    return message;
  }

  toObject(): TargetData {
    return {
      OwnerId: this.OwnerId,
      NnsName: this.NnsName
    };
  }

}

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

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

export interface TokenLifetime {
  Exp: bigint;
  Nbf: bigint;
  Iat: bigint;
}

export class TokenLifetimeImpl implements TokenLifetime {
  Exp!: bigint;
  Nbf!: bigint;
  Iat!: bigint;

  constructor(data?: Partial<TokenLifetime>) {
    this.Exp = data?.Exp ?? 0n;
    this.Nbf = data?.Nbf ?? 0n;
    this.Iat = data?.Iat ?? 0n;
  }

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

    if (this.Exp !== 0n) {
      writer.writeUint64(1, this.Exp);
    }
    if (this.Nbf !== 0n) {
      writer.writeUint64(2, this.Nbf);
    }
    if (this.Iat !== 0n) {
      writer.writeUint64(3, this.Iat);
    }
    return writer.getResultBuffer();
  }

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

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

    return message;
  }

  toObject(): TokenLifetimeData {
    return {
      Exp: this.Exp,
      Nbf: this.Nbf,
      Iat: this.Iat
    };
  }

}

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

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

export interface SessionContextV2 {
  Container?: NeoFsV2Refs.ContainerID;
  Verbs: Verb[];
}

export class SessionContextV2Impl implements SessionContextV2 {
  Container?: NeoFsV2Refs.ContainerID;
  Verbs!: Verb[];

  constructor(data?: Partial<SessionContextV2>) {
    this.Container = data?.Container ?? undefined;
    this.Verbs = data?.Verbs ?? [];
  }

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

    if (this.Container) {
      writer.writeMessage(1, this.Container);
    }
    for (const item of this.Verbs) {
      writer.writeEnum(2, item);
    }
    return writer.getResultBuffer();
  }

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

    // 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(NeoFsV2Refs.ContainerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Verbs
          if (wireType === 2) { // Length-delimited (packed)
            const length = reader.readVarint();
            const endPos = reader.position + length;
            while (reader.position < endPos) {
              message.Verbs.push(reader.readEnum());
            }
          } else {
            // Non-packed encoding - single item
            if (wireType === 0) { message.Verbs.push(reader.readEnum()); }
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SessionContextV2Data {
    return {
      Container: this.Container,
      Verbs: this.Verbs
    };
  }

}

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

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

export interface SessionTokenV2 {
  Body?: SessionTokenV2_Body;
  Signature?: NeoFsV2Refs.Signature;
  Origin?: SessionTokenV2;
}

export class SessionTokenV2Impl implements SessionTokenV2 {
  Body?: SessionTokenV2_Body;
  Signature?: NeoFsV2Refs.Signature;
  Origin?: SessionTokenV2;

  constructor(data?: Partial<SessionTokenV2>) {
    this.Body = data?.Body ?? undefined;
    this.Signature = data?.Signature ?? undefined;
    this.Origin = data?.Origin ?? undefined;
  }

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

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

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

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

    return message;
  }

  toObject(): SessionTokenV2Data {
    return {
      Body: this.Body,
      Signature: this.Signature,
      Origin: this.Origin
    };
  }

}

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

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

export interface SessionTokenV2_Body {
  Version: number;
  Appdata: Uint8Array;
  Issuer?: NeoFsV2Refs.OwnerID;
  Subjects: Target[];
  Lifetime?: TokenLifetime;
  Contexts: SessionContextV2[];
  Final: boolean;
}

export class SessionTokenV2_BodyImpl implements SessionTokenV2_Body {
  Version!: number;
  Appdata!: Uint8Array;
  Issuer?: NeoFsV2Refs.OwnerID;
  Subjects!: Target[];
  Lifetime?: TokenLifetime;
  Contexts!: SessionContextV2[];
  Final!: boolean;

  constructor(data?: Partial<SessionTokenV2_Body>) {
    this.Version = data?.Version ?? 0;
    this.Appdata = data?.Appdata ?? new Uint8Array(0);
    this.Issuer = data?.Issuer ?? undefined;
    this.Subjects = data?.Subjects ?? [];
    this.Lifetime = data?.Lifetime ?? undefined;
    this.Contexts = data?.Contexts ?? [];
    this.Final = data?.Final ?? false;
  }

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

    if (this.Version !== 0) {
      writer.writeUint32(1, this.Version);
    }
    if (this.Appdata.length > 0) {
      writer.writeBytes(2, this.Appdata);
    }
    if (this.Issuer) {
      writer.writeMessage(3, this.Issuer);
    }
    for (const item of this.Subjects) {
      writer.writeMessage(4, item);
    }
    if (this.Lifetime) {
      writer.writeMessage(5, this.Lifetime);
    }
    for (const item of this.Contexts) {
      writer.writeMessage(6, item);
    }
    if (this.Final !== false) {
      writer.writeBool(7, this.Final);
    }
    return writer.getResultBuffer();
  }

  static deserializeBinary(data: Uint8Array): SessionTokenV2_BodyImpl {
    const reader = new BinaryReader(data);
    const message = new SessionTokenV2_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: // Version
          if (wireType === 0) { // Varint
            message.Version = reader.readUint32();
          } else if (wireType === 5) { // 32-bit
            message.Version = reader.readUint32Fixed();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 2: // Appdata
          if (wireType === 2) { // Length-delimited
            message.Appdata = reader.readBytes();
          } else {
            reader.skipField(wireType);
          }
          break;
        case 3: // Issuer
          if (wireType === 2) { // Length-delimited
            message.Issuer = reader.readMessage(NeoFsV2Refs.OwnerIDImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 4: // Subjects
          if (wireType === 2) { // Length-delimited
            message.Subjects.push(reader.readMessage(TargetImpl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 5: // Lifetime
          if (wireType === 2) { // Length-delimited
            message.Lifetime = reader.readMessage(TokenLifetimeImpl.deserializeBinary);
          } else {
            reader.skipField(wireType);
          }
          break;
        case 6: // Contexts
          if (wireType === 2) { // Length-delimited
            message.Contexts.push(reader.readMessage(SessionContextV2Impl.deserializeBinary));
          } else {
            reader.skipField(wireType);
          }
          break;
        case 7: // Final
          if (wireType === 0) { // Varint
            message.Final = reader.readBool();
          } else {
            reader.skipField(wireType);
          }
          break;
        default:
          // Skip unknown fields
          reader.skipField(wireType);
          break;
      }
    }

    return message;
  }

  toObject(): SessionTokenV2_BodyData {
    return {
      Version: this.Version,
      Appdata: this.Appdata,
      Issuer: this.Issuer,
      Subjects: this.Subjects,
      Lifetime: this.Lifetime,
      Contexts: this.Contexts,
      Final: this.Final
    };
  }

}

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

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

} // namespace NeoFsV2Session