npm-core-sdk/connection_pb.ts

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

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { RequestConnectionHeader, RequestPartnerAppHeader, WorkflowExecutionResult } from "./shared_pb.js";
import { Paging } from "./base_pb.js";
import { Connector } from "./connector_pb.js";
import { PartnerApp } from "./partnerApp_pb.js";
import { User } from "./user_pb.js";

/**
 * @generated from message api.Connection
 */
export class Connection extends Message<Connection> {
  /**
   * @generated from field: string ID = 1;
   */
  ID = "";

  /**
   * @generated from field: string Name = 2;
   */
  Name = "";

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

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

  /**
   * @generated from field: string ServiceAccountName = 5;
   */
  ServiceAccountName = "";

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

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

  /**
   * @generated from field: string UriApiStop = 8;
   */
  UriApiStop = "";

  /**
   * @generated from field: string AuthzServer = 9;
   */
  AuthzServer = "";

  /**
   * @generated from field: bool InitializedByConnectionManager = 10;
   */
  InitializedByConnectionManager = false;

  /**
   * @generated from field: string UriApiClear = 11;
   */
  UriApiClear = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.Connection";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "ConnectorID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "PartnerAppID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "ServiceAccountName", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "UriApiStatus", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "UriApiStart", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "UriApiStop", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 9, name: "AuthzServer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 10, name: "InitializedByConnectionManager", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 11, name: "UriApiClear", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message api.CreateConnectionRequest
 */
export class CreateConnectionRequest extends Message<CreateConnectionRequest> {
  /**
   * @generated from field: api.RequestPartnerAppHeader Header = 1;
   */
  Header?: RequestPartnerAppHeader;

  /**
   * @generated from field: string ConnectorID = 2;
   */
  ConnectorID = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.CreateConnectionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestPartnerAppHeader },
    { no: 2, name: "ConnectorID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message api.CreateConnectionResult
 */
export class CreateConnectionResult extends Message<CreateConnectionResult> {
  /**
   * @generated from field: api.Connection Result = 1;
   */
  Result?: Connection;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.CreateConnectionResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Result", kind: "message", T: Connection },
  ]);

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

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

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

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

/**
 * @generated from message api.DeleteConnectionRequest
 */
export class DeleteConnectionRequest extends Message<DeleteConnectionRequest> {
  /**
   * @generated from field: api.RequestPartnerAppHeader Header = 1;
   */
  Header?: RequestPartnerAppHeader;

  /**
   * @generated from field: string ConnectionID = 2;
   */
  ConnectionID = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DeleteConnectionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestPartnerAppHeader },
    { no: 2, name: "ConnectionID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message api.DeleteConnectionResult
 */
export class DeleteConnectionResult extends Message<DeleteConnectionResult> {
  /**
   * @generated from field: api.WorkflowExecutionResult WorkflowExecution = 1;
   */
  WorkflowExecution?: WorkflowExecutionResult;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DeleteConnectionResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "WorkflowExecution", kind: "message", T: WorkflowExecutionResult },
  ]);

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

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

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

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

/**
 * @generated from message api.ListConnectionsRequest
 */
export class ListConnectionsRequest extends Message<ListConnectionsRequest> {
  /**
   * @generated from field: api.RequestPartnerAppHeader Header = 1;
   */
  Header?: RequestPartnerAppHeader;

  /**
   * @generated from field: string ConnectorID = 2;
   */
  ConnectorID = "";

  /**
   * @generated from field: api.Paging Paging = 3;
   */
  Paging?: Paging;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ListConnectionsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestPartnerAppHeader },
    { no: 2, name: "ConnectorID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Paging", kind: "message", T: Paging },
  ]);

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

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

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

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

/**
 * @generated from message api.ListConnectionsResult
 */
export class ListConnectionsResult extends Message<ListConnectionsResult> {
  /**
   * @generated from field: repeated api.Connection Results = 1;
   */
  Results: Connection[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ListConnectionsResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Results", kind: "message", T: Connection, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message api.GetDetailsConnectionsRequest
 */
export class GetDetailsConnectionsRequest extends Message<GetDetailsConnectionsRequest> {
  /**
   * @generated from field: api.RequestConnectionHeader Header = 1;
   */
  Header?: RequestConnectionHeader;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetDetailsConnectionsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestConnectionHeader },
  ]);

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

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

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

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

/**
 * @generated from message api.GetDetailsConnectionsResult
 */
export class GetDetailsConnectionsResult extends Message<GetDetailsConnectionsResult> {
  /**
   * @generated from field: api.Connection Connection = 1;
   */
  Connection?: Connection;

  /**
   * @generated from field: api.Connector Connector = 2;
   */
  Connector?: Connector;

  /**
   * @generated from field: api.PartnerApp PartnerApp = 3;
   */
  PartnerApp?: PartnerApp;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetDetailsConnectionsResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Connection", kind: "message", T: Connection },
    { no: 2, name: "Connector", kind: "message", T: Connector },
    { no: 3, name: "PartnerApp", kind: "message", T: PartnerApp },
  ]);

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

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

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

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

/**
 * @generated from message api.GetStartDetailsConnectionsRequest
 */
export class GetStartDetailsConnectionsRequest extends Message<GetStartDetailsConnectionsRequest> {
  /**
   * @generated from field: api.RequestConnectionHeader Header = 1;
   */
  Header?: RequestConnectionHeader;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetStartDetailsConnectionsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestConnectionHeader },
  ]);

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

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

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

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

/**
 * @generated from message api.GetStartDetailsConnectionsResult
 */
export class GetStartDetailsConnectionsResult extends Message<GetStartDetailsConnectionsResult> {
  /**
   * @generated from field: string UriStartApi = 1;
   */
  UriStartApi = "";

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

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

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

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

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

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

/**
 * @generated from message api.SetRunDetailsConnectionsRequest
 */
export class SetRunDetailsConnectionsRequest extends Message<SetRunDetailsConnectionsRequest> {
  /**
   * @generated from field: api.RequestConnectionHeader Header = 1;
   */
  Header?: RequestConnectionHeader;

  /**
   * @generated from field: string UriApiStatus = 2;
   */
  UriApiStatus = "";

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

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

  /**
   * @generated from field: string UriApiClear = 5;
   */
  UriApiClear = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.SetRunDetailsConnectionsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestConnectionHeader },
    { no: 2, name: "UriApiStatus", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "UriApiStart", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "UriApiStop", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "UriApiClear", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message api.SetRunDetailsConnectionsResult
 */
export class SetRunDetailsConnectionsResult extends Message<SetRunDetailsConnectionsResult> {
  /**
   * @generated from field: api.Connection Result = 1;
   */
  Result?: Connection;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.SetRunDetailsConnectionsResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Result", kind: "message", T: Connection },
  ]);

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

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

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

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

/**
 * @generated from message api.RenewConnectionSARequest
 */
export class RenewConnectionSARequest extends Message<RenewConnectionSARequest> {
  /**
   * @generated from field: api.RequestConnectionHeader Header = 1;
   */
  Header?: RequestConnectionHeader;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.RenewConnectionSARequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestConnectionHeader },
  ]);

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

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

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

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

/**
 * @generated from message api.RenewConnectionSAResult
 */
export class RenewConnectionSAResult extends Message<RenewConnectionSAResult> {
  /**
   * @generated from field: api.User SA = 1;
   */
  SA?: User;

  /**
   * @generated from field: string PEM = 2;
   */
  PEM = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.RenewConnectionSAResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "SA", kind: "message", T: User },
    { no: 2, name: "PEM", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message api.DeleteConnectionInDBRequest
 */
export class DeleteConnectionInDBRequest extends Message<DeleteConnectionInDBRequest> {
  /**
   * @generated from field: string ConnectionID = 1;
   */
  ConnectionID = "";

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.IsConnectionExistRequest
 */
export class IsConnectionExistRequest extends Message<IsConnectionExistRequest> {
  /**
   * @generated from field: string ConnectionID = 1;
   */
  ConnectionID = "";

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

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

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

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

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

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

/**
 * @generated from message api.IsConnectionExistResult
 */
export class IsConnectionExistResult extends Message<IsConnectionExistResult> {
  /**
   * @generated from field: bool Exist = 1;
   */
  Exist = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.IsConnectionExistResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Exist", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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