// @generated by protoc-gen-es v1.4.0 with parameter "target=ts"
// @generated from file mock/v1/ssh.proto (package mock.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";

/**
 * @generated from message mock.v1.Command
 */
export class Command extends Message<Command> {
  /**
   * @generated from field: int32 index = 1;
   */
  index = 0;

  /**
   * @generated from field: string command = 3;
   */
  command = "";

  constructor(data?: PartialMessage<Command>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "mock.v1.Command";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "index", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 3, name: "command", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Command {
    return new Command().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Command {
    return new Command().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Command {
    return new Command().fromJsonString(jsonString, options);
  }

  static equals(a: Command | PlainMessage<Command> | undefined, b: Command | PlainMessage<Command> | undefined): boolean {
    return proto3.util.equals(Command, a, b);
  }
}

/**
 * @generated from message mock.v1.Host
 */
export class Host extends Message<Host> {
  /**
   * @generated from field: string name = 1;
   */
  name = "";

  constructor(data?: PartialMessage<Host>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "mock.v1.Host";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Host {
    return new Host().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Host {
    return new Host().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Host {
    return new Host().fromJsonString(jsonString, options);
  }

  static equals(a: Host | PlainMessage<Host> | undefined, b: Host | PlainMessage<Host> | undefined): boolean {
    return proto3.util.equals(Host, a, b);
  }
}

/**
 * @generated from message mock.v1.HostConfig
 */
export class HostConfig extends Message<HostConfig> {
  /**
   * @generated from field: mock.v1.Host host = 1;
   */
  host?: Host;

  /**
   * @generated from field: int32 port = 2;
   */
  port = 0;

  /**
   * @generated from field: string workdir = 3;
   */
  workdir = "";

  /**
   * @generated from field: string passphrase = 4;
   */
  passphrase = "";

  /**
   * @generated from field: bytes private_key = 5;
   */
  privateKey = new Uint8Array(0);

  /**
   * @generated from field: string auth_username = 6;
   */
  authUsername = "";

  /**
   * @generated from field: string auth_password = 7;
   */
  authPassword = "";

  /**
   * @generated from field: bytes auth_privkey = 8;
   */
  authPrivkey = new Uint8Array(0);

  constructor(data?: PartialMessage<HostConfig>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "mock.v1.HostConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "host", kind: "message", T: Host },
    { no: 2, name: "port", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 3, name: "workdir", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "passphrase", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "private_key", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 6, name: "auth_username", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "auth_password", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "auth_privkey", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HostConfig {
    return new HostConfig().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HostConfig {
    return new HostConfig().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HostConfig {
    return new HostConfig().fromJsonString(jsonString, options);
  }

  static equals(a: HostConfig | PlainMessage<HostConfig> | undefined, b: HostConfig | PlainMessage<HostConfig> | undefined): boolean {
    return proto3.util.equals(HostConfig, a, b);
  }
}

/**
 * @generated from message mock.v1.Query
 */
export class Query extends Message<Query> {
  /**
   * @generated from oneof mock.v1.Query.eq
   */
  eq: {
    /**
     * @generated from field: string name = 1;
     */
    value: string;
    case: "name";
  } | {
    /**
     * @generated from field: int32 port = 2;
     */
    value: number;
    case: "port";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<Query>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "mock.v1.Query";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "eq" },
    { no: 2, name: "port", kind: "scalar", T: 5 /* ScalarType.INT32 */, oneof: "eq" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Query {
    return new Query().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Query {
    return new Query().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Query {
    return new Query().fromJsonString(jsonString, options);
  }

  static equals(a: Query | PlainMessage<Query> | undefined, b: Query | PlainMessage<Query> | undefined): boolean {
    return proto3.util.equals(Query, a, b);
  }
}

/**
 * @generated from message mock.v1.BundleChunk
 */
export class BundleChunk extends Message<BundleChunk> {
  /**
   * @generated from field: bytes data = 1;
   */
  data = new Uint8Array(0);

  constructor(data?: PartialMessage<BundleChunk>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "mock.v1.BundleChunk";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BundleChunk {
    return new BundleChunk().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BundleChunk {
    return new BundleChunk().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BundleChunk {
    return new BundleChunk().fromJsonString(jsonString, options);
  }

  static equals(a: BundleChunk | PlainMessage<BundleChunk> | undefined, b: BundleChunk | PlainMessage<BundleChunk> | undefined): boolean {
    return proto3.util.equals(BundleChunk, a, b);
  }
}

/**
 * @generated from message mock.v1.Empty
 */
export class Empty extends Message<Empty> {
  constructor(data?: PartialMessage<Empty>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "mock.v1.Empty";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Empty {
    return new Empty().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Empty {
    return new Empty().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Empty {
    return new Empty().fromJsonString(jsonString, options);
  }

  static equals(a: Empty | PlainMessage<Empty> | undefined, b: Empty | PlainMessage<Empty> | undefined): boolean {
    return proto3.util.equals(Empty, a, b);
  }
}

