// package: browserstack.sdk.v1
// file: sdk-messages.proto

import * as jspb from "google-protobuf";
import * as sdk_messages_testhub_pb from "./sdk-messages-testhub_pb";
import * as sdk_messages_observability_pb from "./sdk-messages-observability_pb";
import * as sdk_messages_accessibility_pb from "./sdk-messages-accessibility_pb";
import * as sdk_messages_percy_pb from "./sdk-messages-percy_pb";

export class DriverInitRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getPlatformIndex(): number;
  setPlatformIndex(value: number): void;

  getRef(): string;
  setRef(value: string): void;

  getUserInputParams(): Uint8Array | string;
  getUserInputParams_asU8(): Uint8Array;
  getUserInputParams_asB64(): string;
  setUserInputParams(value: Uint8Array | string): void;

  hasHubUrl(): boolean;
  clearHubUrl(): void;
  getHubUrl(): string;
  setHubUrl(value: string): void;

  hasIsSecondaryDriver(): boolean;
  clearIsSecondaryDriver(): void;
  getIsSecondaryDriver(): boolean;
  setIsSecondaryDriver(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DriverInitRequest.AsObject;
  static toObject(includeInstance: boolean, msg: DriverInitRequest): DriverInitRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: DriverInitRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DriverInitRequest;
  static deserializeBinaryFromReader(message: DriverInitRequest, reader: jspb.BinaryReader): DriverInitRequest;
}

export namespace DriverInitRequest {
  export type AsObject = {
    binSessionId: string,
    platformIndex: number,
    ref: string,
    userInputParams: Uint8Array | string,
    hubUrl: string,
    isSecondaryDriver: boolean,
  }
}

export class DriverInitResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getCapabilities(): Uint8Array | string;
  getCapabilities_asU8(): Uint8Array;
  getCapabilities_asB64(): string;
  setCapabilities(value: Uint8Array | string): void;

  hasHubUrl(): boolean;
  clearHubUrl(): void;
  getHubUrl(): string;
  setHubUrl(value: string): void;

  hasIsPrimaryDriver(): boolean;
  clearIsPrimaryDriver(): void;
  getIsPrimaryDriver(): boolean;
  setIsPrimaryDriver(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DriverInitResponse.AsObject;
  static toObject(includeInstance: boolean, msg: DriverInitResponse): DriverInitResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: DriverInitResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DriverInitResponse;
  static deserializeBinaryFromReader(message: DriverInitResponse, reader: jspb.BinaryReader): DriverInitResponse;
}

export namespace DriverInitResponse {
  export type AsObject = {
    success: boolean,
    binSessionId: string,
    capabilities: Uint8Array | string,
    hubUrl: string,
    isPrimaryDriver: boolean,
  }
}

export class AutomationFrameworkInitRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getPlatformIndex(): number;
  setPlatformIndex(value: number): void;

  getFrameworkName(): string;
  setFrameworkName(value: string): void;

  getFrameworkVersion(): string;
  setFrameworkVersion(value: string): void;

  getRef(): string;
  setRef(value: string): void;

  getHubUrl(): string;
  setHubUrl(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AutomationFrameworkInitRequest.AsObject;
  static toObject(includeInstance: boolean, msg: AutomationFrameworkInitRequest): AutomationFrameworkInitRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AutomationFrameworkInitRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AutomationFrameworkInitRequest;
  static deserializeBinaryFromReader(message: AutomationFrameworkInitRequest, reader: jspb.BinaryReader): AutomationFrameworkInitRequest;
}

export namespace AutomationFrameworkInitRequest {
  export type AsObject = {
    binSessionId: string,
    platformIndex: number,
    frameworkName: string,
    frameworkVersion: string,
    ref: string,
    hubUrl: string,
    clientWorkerId: string,
  }
}

export class AutomationFrameworkInitResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  hasHubUrl(): boolean;
  clearHubUrl(): void;
  getHubUrl(): string;
  setHubUrl(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AutomationFrameworkInitResponse.AsObject;
  static toObject(includeInstance: boolean, msg: AutomationFrameworkInitResponse): AutomationFrameworkInitResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AutomationFrameworkInitResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AutomationFrameworkInitResponse;
  static deserializeBinaryFromReader(message: AutomationFrameworkInitResponse, reader: jspb.BinaryReader): AutomationFrameworkInitResponse;
}

export namespace AutomationFrameworkInitResponse {
  export type AsObject = {
    success: boolean,
    hubUrl: string,
  }
}

export class AutomationFrameworkStartRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getPlatformIndex(): number;
  setPlatformIndex(value: number): void;

  getFrameworkName(): string;
  setFrameworkName(value: string): void;

  getFrameworkVersion(): string;
  setFrameworkVersion(value: string): void;

  getRef(): string;
  setRef(value: string): void;

  getFrameworkSessionId(): string;
  setFrameworkSessionId(value: string): void;

  getHubUrl(): string;
  setHubUrl(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AutomationFrameworkStartRequest.AsObject;
  static toObject(includeInstance: boolean, msg: AutomationFrameworkStartRequest): AutomationFrameworkStartRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AutomationFrameworkStartRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AutomationFrameworkStartRequest;
  static deserializeBinaryFromReader(message: AutomationFrameworkStartRequest, reader: jspb.BinaryReader): AutomationFrameworkStartRequest;
}

export namespace AutomationFrameworkStartRequest {
  export type AsObject = {
    binSessionId: string,
    platformIndex: number,
    frameworkName: string,
    frameworkVersion: string,
    ref: string,
    frameworkSessionId: string,
    hubUrl: string,
    clientWorkerId: string,
  }
}

export class AutomationFrameworkStartResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AutomationFrameworkStartResponse.AsObject;
  static toObject(includeInstance: boolean, msg: AutomationFrameworkStartResponse): AutomationFrameworkStartResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AutomationFrameworkStartResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AutomationFrameworkStartResponse;
  static deserializeBinaryFromReader(message: AutomationFrameworkStartResponse, reader: jspb.BinaryReader): AutomationFrameworkStartResponse;
}

export namespace AutomationFrameworkStartResponse {
  export type AsObject = {
    success: boolean,
  }
}

export class AutomationFrameworkStopRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getPlatformIndex(): number;
  setPlatformIndex(value: number): void;

  getFrameworkName(): string;
  setFrameworkName(value: string): void;

  getFrameworkVersion(): string;
  setFrameworkVersion(value: string): void;

  getRef(): string;
  setRef(value: string): void;

  getFrameworkSessionId(): string;
  setFrameworkSessionId(value: string): void;

  getHubUrl(): string;
  setHubUrl(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AutomationFrameworkStopRequest.AsObject;
  static toObject(includeInstance: boolean, msg: AutomationFrameworkStopRequest): AutomationFrameworkStopRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AutomationFrameworkStopRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AutomationFrameworkStopRequest;
  static deserializeBinaryFromReader(message: AutomationFrameworkStopRequest, reader: jspb.BinaryReader): AutomationFrameworkStopRequest;
}

export namespace AutomationFrameworkStopRequest {
  export type AsObject = {
    binSessionId: string,
    platformIndex: number,
    frameworkName: string,
    frameworkVersion: string,
    ref: string,
    frameworkSessionId: string,
    hubUrl: string,
    clientWorkerId: string,
  }
}

export class AutomationFrameworkStopResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AutomationFrameworkStopResponse.AsObject;
  static toObject(includeInstance: boolean, msg: AutomationFrameworkStopResponse): AutomationFrameworkStopResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AutomationFrameworkStopResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AutomationFrameworkStopResponse;
  static deserializeBinaryFromReader(message: AutomationFrameworkStopResponse, reader: jspb.BinaryReader): AutomationFrameworkStopResponse;
}

export namespace AutomationFrameworkStopResponse {
  export type AsObject = {
    success: boolean,
  }
}

export class FindNearestHubRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): FindNearestHubRequest.AsObject;
  static toObject(includeInstance: boolean, msg: FindNearestHubRequest): FindNearestHubRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: FindNearestHubRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): FindNearestHubRequest;
  static deserializeBinaryFromReader(message: FindNearestHubRequest, reader: jspb.BinaryReader): FindNearestHubRequest;
}

export namespace FindNearestHubRequest {
  export type AsObject = {
    binSessionId: string,
    clientWorkerId: string,
  }
}

export class FindNearestHubResponse extends jspb.Message {
  getUrl(): string;
  setUrl(value: string): void;

  getLatency(): number;
  setLatency(value: number): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): FindNearestHubResponse.AsObject;
  static toObject(includeInstance: boolean, msg: FindNearestHubResponse): FindNearestHubResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: FindNearestHubResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): FindNearestHubResponse;
  static deserializeBinaryFromReader(message: FindNearestHubResponse, reader: jspb.BinaryReader): FindNearestHubResponse;
}

export namespace FindNearestHubResponse {
  export type AsObject = {
    url: string,
    latency: number,
  }
}

export class StartBinSessionRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getSdkLanguage(): string;
  setSdkLanguage(value: string): void;

  getSdkVersion(): string;
  setSdkVersion(value: string): void;

  getPathProject(): string;
  setPathProject(value: string): void;

  getPathConfig(): string;
  setPathConfig(value: string): void;

  getEnvVarsMap(): jspb.Map<string, string>;
  clearEnvVarsMap(): void;
  clearCliArgsList(): void;
  getCliArgsList(): Array<string>;
  setCliArgsList(value: Array<string>): void;
  addCliArgs(value: string, index?: number): string;

  clearFrameworksList(): void;
  getFrameworksList(): Array<string>;
  setFrameworksList(value: Array<string>): void;
  addFrameworks(value: string, index?: number): string;

  getFrameworkVersionsMap(): jspb.Map<string, string>;
  clearFrameworkVersionsMap(): void;
  getLanguage(): string;
  setLanguage(value: string): void;

  hasLanguageVersion(): boolean;
  clearLanguageVersion(): void;
  getLanguageVersion(): string;
  setLanguageVersion(value: string): void;

  getTestFramework(): string;
  setTestFramework(value: string): void;

  hasWdioConfig(): boolean;
  clearWdioConfig(): void;
  getWdioConfig(): string;
  setWdioConfig(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  hasPlatformIndex(): boolean;
  clearPlatformIndex(): void;
  getPlatformIndex(): string;
  setPlatformIndex(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StartBinSessionRequest.AsObject;
  static toObject(includeInstance: boolean, msg: StartBinSessionRequest): StartBinSessionRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: StartBinSessionRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StartBinSessionRequest;
  static deserializeBinaryFromReader(message: StartBinSessionRequest, reader: jspb.BinaryReader): StartBinSessionRequest;
}

export namespace StartBinSessionRequest {
  export type AsObject = {
    binSessionId: string,
    sdkLanguage: string,
    sdkVersion: string,
    pathProject: string,
    pathConfig: string,
    envVarsMap: Array<[string, string]>,
    cliArgsList: Array<string>,
    frameworksList: Array<string>,
    frameworkVersionsMap: Array<[string, string]>,
    language: string,
    languageVersion: string,
    testFramework: string,
    wdioConfig: string,
    clientWorkerId: string,
    platformIndex: string,
  }
}

export class StartBinSessionResponse extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getConfig(): string;
  setConfig(value: string): void;

  hasTesthub(): boolean;
  clearTesthub(): void;
  getTesthub(): sdk_messages_testhub_pb.TestHub | undefined;
  setTesthub(value?: sdk_messages_testhub_pb.TestHub): void;

  hasObservability(): boolean;
  clearObservability(): void;
  getObservability(): sdk_messages_observability_pb.Observability | undefined;
  setObservability(value?: sdk_messages_observability_pb.Observability): void;

  hasAccessibility(): boolean;
  clearAccessibility(): void;
  getAccessibility(): sdk_messages_accessibility_pb.Accessibility | undefined;
  setAccessibility(value?: sdk_messages_accessibility_pb.Accessibility): void;

  hasPercy(): boolean;
  clearPercy(): void;
  getPercy(): sdk_messages_percy_pb.Percy | undefined;
  setPercy(value?: sdk_messages_percy_pb.Percy): void;

  hasCliArgs(): boolean;
  clearCliArgs(): void;
  getCliArgs(): string;
  setCliArgs(value: string): void;

  hasSessionFramework(): boolean;
  clearSessionFramework(): void;
  getSessionFramework(): string;
  setSessionFramework(value: string): void;

  hasMaxSupportedPlaywrightVersion(): boolean;
  clearMaxSupportedPlaywrightVersion(): void;
  getMaxSupportedPlaywrightVersion(): string;
  setMaxSupportedPlaywrightVersion(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StartBinSessionResponse.AsObject;
  static toObject(includeInstance: boolean, msg: StartBinSessionResponse): StartBinSessionResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: StartBinSessionResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StartBinSessionResponse;
  static deserializeBinaryFromReader(message: StartBinSessionResponse, reader: jspb.BinaryReader): StartBinSessionResponse;
}

export namespace StartBinSessionResponse {
  export type AsObject = {
    binSessionId: string,
    config: string,
    testhub?: sdk_messages_testhub_pb.TestHub.AsObject,
    observability?: sdk_messages_observability_pb.Observability.AsObject,
    accessibility?: sdk_messages_accessibility_pb.Accessibility.AsObject,
    percy?: sdk_messages_percy_pb.Percy.AsObject,
    cliArgs: string,
    sessionFramework: string,
    maxSupportedPlaywrightVersion: string,
  }
}

export class ConnectBinSessionResponse extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getConfig(): string;
  setConfig(value: string): void;

  hasTesthub(): boolean;
  clearTesthub(): void;
  getTesthub(): sdk_messages_testhub_pb.TestHub | undefined;
  setTesthub(value?: sdk_messages_testhub_pb.TestHub): void;

  hasObservability(): boolean;
  clearObservability(): void;
  getObservability(): sdk_messages_observability_pb.Observability | undefined;
  setObservability(value?: sdk_messages_observability_pb.Observability): void;

  hasAccessibility(): boolean;
  clearAccessibility(): void;
  getAccessibility(): sdk_messages_accessibility_pb.Accessibility | undefined;
  setAccessibility(value?: sdk_messages_accessibility_pb.Accessibility): void;

  hasPercy(): boolean;
  clearPercy(): void;
  getPercy(): sdk_messages_percy_pb.Percy | undefined;
  setPercy(value?: sdk_messages_percy_pb.Percy): void;

  hasSessionFramework(): boolean;
  clearSessionFramework(): void;
  getSessionFramework(): string;
  setSessionFramework(value: string): void;

  hasTestOrchestration(): boolean;
  clearTestOrchestration(): void;
  getTestOrchestration(): TestOrchestration | undefined;
  setTestOrchestration(value?: TestOrchestration): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ConnectBinSessionResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ConnectBinSessionResponse): ConnectBinSessionResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ConnectBinSessionResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ConnectBinSessionResponse;
  static deserializeBinaryFromReader(message: ConnectBinSessionResponse, reader: jspb.BinaryReader): ConnectBinSessionResponse;
}

export namespace ConnectBinSessionResponse {
  export type AsObject = {
    binSessionId: string,
    config: string,
    testhub?: sdk_messages_testhub_pb.TestHub.AsObject,
    observability?: sdk_messages_observability_pb.Observability.AsObject,
    accessibility?: sdk_messages_accessibility_pb.Accessibility.AsObject,
    percy?: sdk_messages_percy_pb.Percy.AsObject,
    sessionFramework: string,
    testOrchestration?: TestOrchestration.AsObject,
  }
}

export class TestOrchestration extends jspb.Message {
  hasRunPreviouslyFailedFirst(): boolean;
  clearRunPreviouslyFailedFirst(): void;
  getRunPreviouslyFailedFirst(): boolean;
  setRunPreviouslyFailedFirst(value: boolean): void;

  hasRetryTestsOnFailure(): boolean;
  clearRetryTestsOnFailure(): void;
  getRetryTestsOnFailure(): RetryTestsOnFailure | undefined;
  setRetryTestsOnFailure(value?: RetryTestsOnFailure): void;

  hasAbortBuildOnFailure(): boolean;
  clearAbortBuildOnFailure(): void;
  getAbortBuildOnFailure(): AbortBuildOnFailure | undefined;
  setAbortBuildOnFailure(value?: AbortBuildOnFailure): void;

  hasRerunPreviouslyFailed(): boolean;
  clearRerunPreviouslyFailed(): void;
  getRerunPreviouslyFailed(): boolean;
  setRerunPreviouslyFailed(value: boolean): void;

  hasSkipFailingAndFlaky(): boolean;
  clearSkipFailingAndFlaky(): void;
  getSkipFailingAndFlaky(): boolean;
  setSkipFailingAndFlaky(value: boolean): void;

  hasRunSmartSelection(): boolean;
  clearRunSmartSelection(): void;
  getRunSmartSelection(): RunSmartSelection | undefined;
  setRunSmartSelection(value?: RunSmartSelection): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TestOrchestration.AsObject;
  static toObject(includeInstance: boolean, msg: TestOrchestration): TestOrchestration.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: TestOrchestration, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TestOrchestration;
  static deserializeBinaryFromReader(message: TestOrchestration, reader: jspb.BinaryReader): TestOrchestration;
}

export namespace TestOrchestration {
  export type AsObject = {
    runPreviouslyFailedFirst: boolean,
    retryTestsOnFailure?: RetryTestsOnFailure.AsObject,
    abortBuildOnFailure?: AbortBuildOnFailure.AsObject,
    rerunPreviouslyFailed: boolean,
    skipFailingAndFlaky: boolean,
    runSmartSelection?: RunSmartSelection.AsObject,
  }
}

export class RunSmartSelection extends jspb.Message {
  getEnabled(): boolean;
  setEnabled(value: boolean): void;

  getMode(): string;
  setMode(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RunSmartSelection.AsObject;
  static toObject(includeInstance: boolean, msg: RunSmartSelection): RunSmartSelection.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: RunSmartSelection, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RunSmartSelection;
  static deserializeBinaryFromReader(message: RunSmartSelection, reader: jspb.BinaryReader): RunSmartSelection;
}

export namespace RunSmartSelection {
  export type AsObject = {
    enabled: boolean,
    mode: string,
  }
}

export class RetryTestsOnFailure extends jspb.Message {
  getEnabled(): boolean;
  setEnabled(value: boolean): void;

  getMaxRetries(): number;
  setMaxRetries(value: number): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RetryTestsOnFailure.AsObject;
  static toObject(includeInstance: boolean, msg: RetryTestsOnFailure): RetryTestsOnFailure.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: RetryTestsOnFailure, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RetryTestsOnFailure;
  static deserializeBinaryFromReader(message: RetryTestsOnFailure, reader: jspb.BinaryReader): RetryTestsOnFailure;
}

export namespace RetryTestsOnFailure {
  export type AsObject = {
    enabled: boolean,
    maxRetries: number,
  }
}

export class AbortBuildOnFailure extends jspb.Message {
  getEnabled(): boolean;
  setEnabled(value: boolean): void;

  getMaxFailures(): number;
  setMaxFailures(value: number): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AbortBuildOnFailure.AsObject;
  static toObject(includeInstance: boolean, msg: AbortBuildOnFailure): AbortBuildOnFailure.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AbortBuildOnFailure, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AbortBuildOnFailure;
  static deserializeBinaryFromReader(message: AbortBuildOnFailure, reader: jspb.BinaryReader): AbortBuildOnFailure;
}

export namespace AbortBuildOnFailure {
  export type AsObject = {
    enabled: boolean,
    maxFailures: number,
  }
}

export class TestOrchestrationRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  clearTestFilesList(): void;
  getTestFilesList(): Array<string>;
  setTestFilesList(value: Array<string>): void;
  addTestFiles(value: string, index?: number): string;

  hasOrchestrationStrategy(): boolean;
  clearOrchestrationStrategy(): void;
  getOrchestrationStrategy(): string;
  setOrchestrationStrategy(value: string): void;

  hasOrchestrationMetadata(): boolean;
  clearOrchestrationMetadata(): void;
  getOrchestrationMetadata(): string;
  setOrchestrationMetadata(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TestOrchestrationRequest.AsObject;
  static toObject(includeInstance: boolean, msg: TestOrchestrationRequest): TestOrchestrationRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: TestOrchestrationRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TestOrchestrationRequest;
  static deserializeBinaryFromReader(message: TestOrchestrationRequest, reader: jspb.BinaryReader): TestOrchestrationRequest;
}

export namespace TestOrchestrationRequest {
  export type AsObject = {
    binSessionId: string,
    testFilesList: Array<string>,
    orchestrationStrategy: string,
    orchestrationMetadata: string,
  }
}

export class TestOrchestrationResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  clearOrderedTestFilesList(): void;
  getOrderedTestFilesList(): Array<string>;
  setOrderedTestFilesList(value: Array<string>): void;
  addOrderedTestFiles(value: string, index?: number): string;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TestOrchestrationResponse.AsObject;
  static toObject(includeInstance: boolean, msg: TestOrchestrationResponse): TestOrchestrationResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: TestOrchestrationResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TestOrchestrationResponse;
  static deserializeBinaryFromReader(message: TestOrchestrationResponse, reader: jspb.BinaryReader): TestOrchestrationResponse;
}

export namespace TestOrchestrationResponse {
  export type AsObject = {
    success: boolean,
    orderedTestFilesList: Array<string>,
  }
}

export class StopBinSessionRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  hasExitCode(): boolean;
  clearExitCode(): void;
  getExitCode(): number;
  setExitCode(value: number): void;

  hasExitSignal(): boolean;
  clearExitSignal(): void;
  getExitSignal(): string;
  setExitSignal(value: string): void;

  hasExitReason(): boolean;
  clearExitReason(): void;
  getExitReason(): string;
  setExitReason(value: string): void;

  hasCustomMetadata(): boolean;
  clearCustomMetadata(): void;
  getCustomMetadata(): string;
  setCustomMetadata(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StopBinSessionRequest.AsObject;
  static toObject(includeInstance: boolean, msg: StopBinSessionRequest): StopBinSessionRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: StopBinSessionRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StopBinSessionRequest;
  static deserializeBinaryFromReader(message: StopBinSessionRequest, reader: jspb.BinaryReader): StopBinSessionRequest;
}

export namespace StopBinSessionRequest {
  export type AsObject = {
    binSessionId: string,
    exitCode: number,
    exitSignal: string,
    exitReason: string,
    customMetadata: string,
  }
}

export class StopBinSessionResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  hasAutomateBuildlink(): boolean;
  clearAutomateBuildlink(): void;
  getAutomateBuildlink(): string;
  setAutomateBuildlink(value: string): void;

  hasHashedId(): boolean;
  clearHashedId(): void;
  getHashedId(): string;
  setHashedId(value: string): void;

  clearEntriesList(): void;
  getEntriesList(): Array<CustomerVisibleSummaryEntry>;
  setEntriesList(value: Array<CustomerVisibleSummaryEntry>): void;
  addEntries(value?: CustomerVisibleSummaryEntry, index?: number): CustomerVisibleSummaryEntry;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StopBinSessionResponse.AsObject;
  static toObject(includeInstance: boolean, msg: StopBinSessionResponse): StopBinSessionResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: StopBinSessionResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StopBinSessionResponse;
  static deserializeBinaryFromReader(message: StopBinSessionResponse, reader: jspb.BinaryReader): StopBinSessionResponse;
}

export namespace StopBinSessionResponse {
  export type AsObject = {
    success: boolean,
    error: string,
    automateBuildlink: string,
    hashedId: string,
    entriesList: Array<CustomerVisibleSummaryEntry.AsObject>,
  }
}

export class CustomerVisibleSummaryEntry extends jspb.Message {
  getEntryType(): string;
  setEntryType(value: string): void;

  getSeverity(): string;
  setSeverity(value: string): void;

  getBody(): string;
  setBody(value: string): void;

  hasDocLink(): boolean;
  clearDocLink(): void;
  getDocLink(): string;
  setDocLink(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CustomerVisibleSummaryEntry.AsObject;
  static toObject(includeInstance: boolean, msg: CustomerVisibleSummaryEntry): CustomerVisibleSummaryEntry.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: CustomerVisibleSummaryEntry, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CustomerVisibleSummaryEntry;
  static deserializeBinaryFromReader(message: CustomerVisibleSummaryEntry, reader: jspb.BinaryReader): CustomerVisibleSummaryEntry;
}

export namespace CustomerVisibleSummaryEntry {
  export type AsObject = {
    entryType: string,
    severity: string,
    body: string,
    docLink: string,
  }
}

export class PlaywrightConfigRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getConfig(): string;
  setConfig(value: string): void;

  getRef(): string;
  setRef(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): PlaywrightConfigRequest.AsObject;
  static toObject(includeInstance: boolean, msg: PlaywrightConfigRequest): PlaywrightConfigRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: PlaywrightConfigRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): PlaywrightConfigRequest;
  static deserializeBinaryFromReader(message: PlaywrightConfigRequest, reader: jspb.BinaryReader): PlaywrightConfigRequest;
}

export namespace PlaywrightConfigRequest {
  export type AsObject = {
    binSessionId: string,
    config: string,
    ref: string,
    clientWorkerId: string,
  }
}

export class PlaywrightConfigResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  getConfig(): string;
  setConfig(value: string): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): PlaywrightConfigResponse.AsObject;
  static toObject(includeInstance: boolean, msg: PlaywrightConfigResponse): PlaywrightConfigResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: PlaywrightConfigResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): PlaywrightConfigResponse;
  static deserializeBinaryFromReader(message: PlaywrightConfigResponse, reader: jspb.BinaryReader): PlaywrightConfigResponse;
}

export namespace PlaywrightConfigResponse {
  export type AsObject = {
    success: boolean,
    config: string,
    error: string,
  }
}

export class DetoxConfigRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DetoxConfigRequest.AsObject;
  static toObject(includeInstance: boolean, msg: DetoxConfigRequest): DetoxConfigRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: DetoxConfigRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DetoxConfigRequest;
  static deserializeBinaryFromReader(message: DetoxConfigRequest, reader: jspb.BinaryReader): DetoxConfigRequest;
}

export namespace DetoxConfigRequest {
  export type AsObject = {
    binSessionId: string,
    clientWorkerId: string,
  }
}

export class DetoxConfigResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  getConfig(): string;
  setConfig(value: string): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  hasLocalBound(): boolean;
  clearLocalBound(): void;
  getLocalBound(): boolean;
  setLocalBound(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DetoxConfigResponse.AsObject;
  static toObject(includeInstance: boolean, msg: DetoxConfigResponse): DetoxConfigResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: DetoxConfigResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DetoxConfigResponse;
  static deserializeBinaryFromReader(message: DetoxConfigResponse, reader: jspb.BinaryReader): DetoxConfigResponse;
}

export namespace DetoxConfigResponse {
  export type AsObject = {
    success: boolean,
    config: string,
    error: string,
    localBound: boolean,
  }
}

export class DetoxMarkSessionsRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getSessions(): string;
  setSessions(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DetoxMarkSessionsRequest.AsObject;
  static toObject(includeInstance: boolean, msg: DetoxMarkSessionsRequest): DetoxMarkSessionsRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: DetoxMarkSessionsRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DetoxMarkSessionsRequest;
  static deserializeBinaryFromReader(message: DetoxMarkSessionsRequest, reader: jspb.BinaryReader): DetoxMarkSessionsRequest;
}

export namespace DetoxMarkSessionsRequest {
  export type AsObject = {
    binSessionId: string,
    sessions: string,
    clientWorkerId: string,
  }
}

export class DetoxMarkSessionsResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DetoxMarkSessionsResponse.AsObject;
  static toObject(includeInstance: boolean, msg: DetoxMarkSessionsResponse): DetoxMarkSessionsResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: DetoxMarkSessionsResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DetoxMarkSessionsResponse;
  static deserializeBinaryFromReader(message: DetoxMarkSessionsResponse, reader: jspb.BinaryReader): DetoxMarkSessionsResponse;
}

export namespace DetoxMarkSessionsResponse {
  export type AsObject = {
    success: boolean,
    error: string,
  }
}

export class ConnectBinSessionRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  hasPlatformIndex(): boolean;
  clearPlatformIndex(): void;
  getPlatformIndex(): number;
  setPlatformIndex(value: number): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ConnectBinSessionRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ConnectBinSessionRequest): ConnectBinSessionRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ConnectBinSessionRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ConnectBinSessionRequest;
  static deserializeBinaryFromReader(message: ConnectBinSessionRequest, reader: jspb.BinaryReader): ConnectBinSessionRequest;
}

export namespace ConnectBinSessionRequest {
  export type AsObject = {
    binSessionId: string,
    platformIndex: number,
    clientWorkerId: string,
  }
}

export class TestFrameworkEventRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getPlatformIndex(): number;
  setPlatformIndex(value: number): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  getTestFrameworkName(): string;
  setTestFrameworkName(value: string): void;

  getTestFrameworkVersion(): string;
  setTestFrameworkVersion(value: string): void;

  getUuid(): string;
  setUuid(value: string): void;

  getEventJson(): Uint8Array | string;
  getEventJson_asU8(): Uint8Array;
  getEventJson_asB64(): string;
  setEventJson(value: Uint8Array | string): void;

  getTestFrameworkState(): string;
  setTestFrameworkState(value: string): void;

  getTestHookState(): string;
  setTestHookState(value: string): void;

  getStartedAt(): string;
  setStartedAt(value: string): void;

  hasEndedAt(): boolean;
  clearEndedAt(): void;
  getEndedAt(): string;
  setEndedAt(value: string): void;

  hasExecutionContext(): boolean;
  clearExecutionContext(): void;
  getExecutionContext(): ExecutionContext | undefined;
  setExecutionContext(value?: ExecutionContext): void;

  hasTestIdentifier(): boolean;
  clearTestIdentifier(): void;
  getTestIdentifier(): string;
  setTestIdentifier(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TestFrameworkEventRequest.AsObject;
  static toObject(includeInstance: boolean, msg: TestFrameworkEventRequest): TestFrameworkEventRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: TestFrameworkEventRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TestFrameworkEventRequest;
  static deserializeBinaryFromReader(message: TestFrameworkEventRequest, reader: jspb.BinaryReader): TestFrameworkEventRequest;
}

export namespace TestFrameworkEventRequest {
  export type AsObject = {
    binSessionId: string,
    platformIndex: number,
    clientWorkerId: string,
    testFrameworkName: string,
    testFrameworkVersion: string,
    uuid: string,
    eventJson: Uint8Array | string,
    testFrameworkState: string,
    testHookState: string,
    startedAt: string,
    endedAt: string,
    executionContext?: ExecutionContext.AsObject,
    testIdentifier: string,
  }
}

export class ExecutionContext extends jspb.Message {
  getThreadId(): string;
  setThreadId(value: string): void;

  hasProcessId(): boolean;
  clearProcessId(): void;
  getProcessId(): string;
  setProcessId(value: string): void;

  hasHash(): boolean;
  clearHash(): void;
  getHash(): string;
  setHash(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ExecutionContext.AsObject;
  static toObject(includeInstance: boolean, msg: ExecutionContext): ExecutionContext.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ExecutionContext, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ExecutionContext;
  static deserializeBinaryFromReader(message: ExecutionContext, reader: jspb.BinaryReader): ExecutionContext;
}

export namespace ExecutionContext {
  export type AsObject = {
    threadId: string,
    processId: string,
    hash: string,
  }
}

export class TestFrameworkEventResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TestFrameworkEventResponse.AsObject;
  static toObject(includeInstance: boolean, msg: TestFrameworkEventResponse): TestFrameworkEventResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: TestFrameworkEventResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TestFrameworkEventResponse;
  static deserializeBinaryFromReader(message: TestFrameworkEventResponse, reader: jspb.BinaryReader): TestFrameworkEventResponse;
}

export namespace TestFrameworkEventResponse {
  export type AsObject = {
    success: boolean,
    error: string,
  }
}

export class EnqueueTestEventRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getEventUrl(): string;
  setEventUrl(value: string): void;

  getEventDataJson(): Uint8Array | string;
  getEventDataJson_asU8(): Uint8Array;
  getEventDataJson_asB64(): string;
  setEventDataJson(value: Uint8Array | string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  hasPlatformIndex(): boolean;
  clearPlatformIndex(): void;
  getPlatformIndex(): string;
  setPlatformIndex(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): EnqueueTestEventRequest.AsObject;
  static toObject(includeInstance: boolean, msg: EnqueueTestEventRequest): EnqueueTestEventRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: EnqueueTestEventRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): EnqueueTestEventRequest;
  static deserializeBinaryFromReader(message: EnqueueTestEventRequest, reader: jspb.BinaryReader): EnqueueTestEventRequest;
}

export namespace EnqueueTestEventRequest {
  export type AsObject = {
    binSessionId: string,
    eventUrl: string,
    eventDataJson: Uint8Array | string,
    clientWorkerId: string,
    platformIndex: string,
  }
}

export class EnqueueTestEventResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): EnqueueTestEventResponse.AsObject;
  static toObject(includeInstance: boolean, msg: EnqueueTestEventResponse): EnqueueTestEventResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: EnqueueTestEventResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): EnqueueTestEventResponse;
  static deserializeBinaryFromReader(message: EnqueueTestEventResponse, reader: jspb.BinaryReader): EnqueueTestEventResponse;
}

export namespace EnqueueTestEventResponse {
  export type AsObject = {
    success: boolean,
    error: string,
  }
}

export class LogCreatedEventRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getPlatformIndex(): number;
  setPlatformIndex(value: number): void;

  clearLogsList(): void;
  getLogsList(): Array<LogCreatedEventRequest.LogEntry>;
  setLogsList(value: Array<LogCreatedEventRequest.LogEntry>): void;
  addLogs(value?: LogCreatedEventRequest.LogEntry, index?: number): LogCreatedEventRequest.LogEntry;

  hasExecutionContext(): boolean;
  clearExecutionContext(): void;
  getExecutionContext(): ExecutionContext | undefined;
  setExecutionContext(value?: ExecutionContext): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): LogCreatedEventRequest.AsObject;
  static toObject(includeInstance: boolean, msg: LogCreatedEventRequest): LogCreatedEventRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: LogCreatedEventRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): LogCreatedEventRequest;
  static deserializeBinaryFromReader(message: LogCreatedEventRequest, reader: jspb.BinaryReader): LogCreatedEventRequest;
}

export namespace LogCreatedEventRequest {
  export type AsObject = {
    binSessionId: string,
    platformIndex: number,
    logsList: Array<LogCreatedEventRequest.LogEntry.AsObject>,
    executionContext?: ExecutionContext.AsObject,
    clientWorkerId: string,
  }

  export class LogEntry extends jspb.Message {
    getTestFrameworkName(): string;
    setTestFrameworkName(value: string): void;

    getTestFrameworkVersion(): string;
    setTestFrameworkVersion(value: string): void;

    getTestFrameworkState(): string;
    setTestFrameworkState(value: string): void;

    getTimestamp(): string;
    setTimestamp(value: string): void;

    getUuid(): string;
    setUuid(value: string): void;

    getKind(): string;
    setKind(value: string): void;

    getMessage(): Uint8Array | string;
    getMessage_asU8(): Uint8Array;
    getMessage_asB64(): string;
    setMessage(value: Uint8Array | string): void;

    hasLevel(): boolean;
    clearLevel(): void;
    getLevel(): string;
    setLevel(value: string): void;

    hasFileName(): boolean;
    clearFileName(): void;
    getFileName(): string;
    setFileName(value: string): void;

    hasFileSize(): boolean;
    clearFileSize(): void;
    getFileSize(): number;
    setFileSize(value: number): void;

    hasFilePath(): boolean;
    clearFilePath(): void;
    getFilePath(): string;
    setFilePath(value: string): void;

    hasAttachmentType(): boolean;
    clearAttachmentType(): void;
    getAttachmentType(): string;
    setAttachmentType(value: string): void;

    hasTestIdentifier(): boolean;
    clearTestIdentifier(): void;
    getTestIdentifier(): string;
    setTestIdentifier(value: string): void;

    hasDuration(): boolean;
    clearDuration(): void;
    getDuration(): number;
    setDuration(value: number): void;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): LogEntry.AsObject;
    static toObject(includeInstance: boolean, msg: LogEntry): LogEntry.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: LogEntry, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): LogEntry;
    static deserializeBinaryFromReader(message: LogEntry, reader: jspb.BinaryReader): LogEntry;
  }

  export namespace LogEntry {
    export type AsObject = {
      testFrameworkName: string,
      testFrameworkVersion: string,
      testFrameworkState: string,
      timestamp: string,
      uuid: string,
      kind: string,
      message: Uint8Array | string,
      level: string,
      fileName: string,
      fileSize: number,
      filePath: string,
      attachmentType: string,
      testIdentifier: string,
      duration: number,
    }
  }
}

export class LogCreatedEventResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): LogCreatedEventResponse.AsObject;
  static toObject(includeInstance: boolean, msg: LogCreatedEventResponse): LogCreatedEventResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: LogCreatedEventResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): LogCreatedEventResponse;
  static deserializeBinaryFromReader(message: LogCreatedEventResponse, reader: jspb.BinaryReader): LogCreatedEventResponse;
}

export namespace LogCreatedEventResponse {
  export type AsObject = {
    success: boolean,
    error: string,
  }
}

export class TestSessionEventRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getPlatformIndex(): number;
  setPlatformIndex(value: number): void;

  getTestFrameworkName(): string;
  setTestFrameworkName(value: string): void;

  getTestFrameworkVersion(): string;
  setTestFrameworkVersion(value: string): void;

  getTestFrameworkState(): string;
  setTestFrameworkState(value: string): void;

  getTestHookState(): string;
  setTestHookState(value: string): void;

  getTestUuid(): string;
  setTestUuid(value: string): void;

  clearAutomationSessionsList(): void;
  getAutomationSessionsList(): Array<TestSessionEventRequest.AutomationSession>;
  setAutomationSessionsList(value: Array<TestSessionEventRequest.AutomationSession>): void;
  addAutomationSessions(value?: TestSessionEventRequest.AutomationSession, index?: number): TestSessionEventRequest.AutomationSession;

  hasExecutionContext(): boolean;
  clearExecutionContext(): void;
  getExecutionContext(): ExecutionContext | undefined;
  setExecutionContext(value?: ExecutionContext): void;

  hasCapabilities(): boolean;
  clearCapabilities(): void;
  getCapabilities(): Uint8Array | string;
  getCapabilities_asU8(): Uint8Array;
  getCapabilities_asB64(): string;
  setCapabilities(value: Uint8Array | string): void;

  hasTestIdentifier(): boolean;
  clearTestIdentifier(): void;
  getTestIdentifier(): string;
  setTestIdentifier(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TestSessionEventRequest.AsObject;
  static toObject(includeInstance: boolean, msg: TestSessionEventRequest): TestSessionEventRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: TestSessionEventRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TestSessionEventRequest;
  static deserializeBinaryFromReader(message: TestSessionEventRequest, reader: jspb.BinaryReader): TestSessionEventRequest;
}

export namespace TestSessionEventRequest {
  export type AsObject = {
    binSessionId: string,
    platformIndex: number,
    testFrameworkName: string,
    testFrameworkVersion: string,
    testFrameworkState: string,
    testHookState: string,
    testUuid: string,
    automationSessionsList: Array<TestSessionEventRequest.AutomationSession.AsObject>,
    executionContext?: ExecutionContext.AsObject,
    capabilities: Uint8Array | string,
    testIdentifier: string,
    clientWorkerId: string,
  }

  export class AutomationSession extends jspb.Message {
    getProvider(): string;
    setProvider(value: string): void;

    hasProduct(): boolean;
    clearProduct(): void;
    getProduct(): string;
    setProduct(value: string): void;

    getFrameworkName(): string;
    setFrameworkName(value: string): void;

    getFrameworkVersion(): string;
    setFrameworkVersion(value: string): void;

    getFrameworkSessionId(): string;
    setFrameworkSessionId(value: string): void;

    hasRef(): boolean;
    clearRef(): void;
    getRef(): string;
    setRef(value: string): void;

    hasHubUrl(): boolean;
    clearHubUrl(): void;
    getHubUrl(): string;
    setHubUrl(value: string): void;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AutomationSession.AsObject;
    static toObject(includeInstance: boolean, msg: AutomationSession): AutomationSession.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AutomationSession, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AutomationSession;
    static deserializeBinaryFromReader(message: AutomationSession, reader: jspb.BinaryReader): AutomationSession;
  }

  export namespace AutomationSession {
    export type AsObject = {
      provider: string,
      product: string,
      frameworkName: string,
      frameworkVersion: string,
      frameworkSessionId: string,
      ref: string,
      hubUrl: string,
    }
  }
}

export class TestSessionEventResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TestSessionEventResponse.AsObject;
  static toObject(includeInstance: boolean, msg: TestSessionEventResponse): TestSessionEventResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: TestSessionEventResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TestSessionEventResponse;
  static deserializeBinaryFromReader(message: TestSessionEventResponse, reader: jspb.BinaryReader): TestSessionEventResponse;
}

export namespace TestSessionEventResponse {
  export type AsObject = {
    success: boolean,
    error: string,
  }
}

export class FetchDriverExecuteParamsEventRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getProduct(): string;
  setProduct(value: string): void;

  hasScriptName(): boolean;
  clearScriptName(): void;
  getScriptName(): string;
  setScriptName(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  hasPlatformIndex(): boolean;
  clearPlatformIndex(): void;
  getPlatformIndex(): string;
  setPlatformIndex(value: string): void;

  hasTestIdentifier(): boolean;
  clearTestIdentifier(): void;
  getTestIdentifier(): string;
  setTestIdentifier(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): FetchDriverExecuteParamsEventRequest.AsObject;
  static toObject(includeInstance: boolean, msg: FetchDriverExecuteParamsEventRequest): FetchDriverExecuteParamsEventRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: FetchDriverExecuteParamsEventRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): FetchDriverExecuteParamsEventRequest;
  static deserializeBinaryFromReader(message: FetchDriverExecuteParamsEventRequest, reader: jspb.BinaryReader): FetchDriverExecuteParamsEventRequest;
}

export namespace FetchDriverExecuteParamsEventRequest {
  export type AsObject = {
    binSessionId: string,
    product: string,
    scriptName: string,
    clientWorkerId: string,
    platformIndex: string,
    testIdentifier: string,
  }
}

export class FetchDriverExecuteParamsEventResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  hasScript(): boolean;
  clearScript(): void;
  getScript(): string;
  setScript(value: string): void;

  hasAccessibilityExecuteParams(): boolean;
  clearAccessibilityExecuteParams(): void;
  getAccessibilityExecuteParams(): Uint8Array | string;
  getAccessibilityExecuteParams_asU8(): Uint8Array;
  getAccessibilityExecuteParams_asB64(): string;
  setAccessibilityExecuteParams(value: Uint8Array | string): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): FetchDriverExecuteParamsEventResponse.AsObject;
  static toObject(includeInstance: boolean, msg: FetchDriverExecuteParamsEventResponse): FetchDriverExecuteParamsEventResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: FetchDriverExecuteParamsEventResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): FetchDriverExecuteParamsEventResponse;
  static deserializeBinaryFromReader(message: FetchDriverExecuteParamsEventResponse, reader: jspb.BinaryReader): FetchDriverExecuteParamsEventResponse;
}

export namespace FetchDriverExecuteParamsEventResponse {
  export type AsObject = {
    success: boolean,
    script: string,
    accessibilityExecuteParams: Uint8Array | string,
    error: string,
  }
}

export class ReportClientTroubleshootingErrorRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getErrorKey(): string;
  setErrorKey(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  hasPlatformIndex(): boolean;
  clearPlatformIndex(): void;
  getPlatformIndex(): string;
  setPlatformIndex(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ReportClientTroubleshootingErrorRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ReportClientTroubleshootingErrorRequest): ReportClientTroubleshootingErrorRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ReportClientTroubleshootingErrorRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ReportClientTroubleshootingErrorRequest;
  static deserializeBinaryFromReader(message: ReportClientTroubleshootingErrorRequest, reader: jspb.BinaryReader): ReportClientTroubleshootingErrorRequest;
}

export namespace ReportClientTroubleshootingErrorRequest {
  export type AsObject = {
    binSessionId: string,
    errorKey: string,
    clientWorkerId: string,
    platformIndex: string,
  }
}

export class ReportClientTroubleshootingErrorResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  getErrorCode(): string;
  setErrorCode(value: string): void;

  getErrorMessage(): string;
  setErrorMessage(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ReportClientTroubleshootingErrorResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ReportClientTroubleshootingErrorResponse): ReportClientTroubleshootingErrorResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ReportClientTroubleshootingErrorResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ReportClientTroubleshootingErrorResponse;
  static deserializeBinaryFromReader(message: ReportClientTroubleshootingErrorResponse, reader: jspb.BinaryReader): ReportClientTroubleshootingErrorResponse;
}

export namespace ReportClientTroubleshootingErrorResponse {
  export type AsObject = {
    success: boolean,
    errorCode: string,
    errorMessage: string,
  }
}

export class GetAggregatedClientTroubleshootingErrorsRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  hasPlatformIndex(): boolean;
  clearPlatformIndex(): void;
  getPlatformIndex(): string;
  setPlatformIndex(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetAggregatedClientTroubleshootingErrorsRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetAggregatedClientTroubleshootingErrorsRequest): GetAggregatedClientTroubleshootingErrorsRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetAggregatedClientTroubleshootingErrorsRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetAggregatedClientTroubleshootingErrorsRequest;
  static deserializeBinaryFromReader(message: GetAggregatedClientTroubleshootingErrorsRequest, reader: jspb.BinaryReader): GetAggregatedClientTroubleshootingErrorsRequest;
}

export namespace GetAggregatedClientTroubleshootingErrorsRequest {
  export type AsObject = {
    binSessionId: string,
    clientWorkerId: string,
    platformIndex: string,
  }
}

export class GetAggregatedClientTroubleshootingErrorsResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  getErrorCodes(): Uint8Array | string;
  getErrorCodes_asU8(): Uint8Array;
  getErrorCodes_asB64(): string;
  setErrorCodes(value: Uint8Array | string): void;

  getFinalErrorMessage(): string;
  setFinalErrorMessage(value: string): void;

  hasDocumentationLink(): boolean;
  clearDocumentationLink(): void;
  getDocumentationLink(): string;
  setDocumentationLink(value: string): void;

  hasErrorCodesOccurredInCli(): boolean;
  clearErrorCodesOccurredInCli(): void;
  getErrorCodesOccurredInCli(): Uint8Array | string;
  getErrorCodesOccurredInCli_asU8(): Uint8Array;
  getErrorCodesOccurredInCli_asB64(): string;
  setErrorCodesOccurredInCli(value: Uint8Array | string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetAggregatedClientTroubleshootingErrorsResponse.AsObject;
  static toObject(includeInstance: boolean, msg: GetAggregatedClientTroubleshootingErrorsResponse): GetAggregatedClientTroubleshootingErrorsResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetAggregatedClientTroubleshootingErrorsResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetAggregatedClientTroubleshootingErrorsResponse;
  static deserializeBinaryFromReader(message: GetAggregatedClientTroubleshootingErrorsResponse, reader: jspb.BinaryReader): GetAggregatedClientTroubleshootingErrorsResponse;
}

export namespace GetAggregatedClientTroubleshootingErrorsResponse {
  export type AsObject = {
    success: boolean,
    errorCodes: Uint8Array | string,
    finalErrorMessage: string,
    documentationLink: string,
    errorCodesOccurredInCli: Uint8Array | string,
  }
}

export class TestCafeConfigRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TestCafeConfigRequest.AsObject;
  static toObject(includeInstance: boolean, msg: TestCafeConfigRequest): TestCafeConfigRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: TestCafeConfigRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TestCafeConfigRequest;
  static deserializeBinaryFromReader(message: TestCafeConfigRequest, reader: jspb.BinaryReader): TestCafeConfigRequest;
}

export namespace TestCafeConfigRequest {
  export type AsObject = {
    binSessionId: string,
    clientWorkerId: string,
  }
}

export class TestCafeConfigResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  getBrowserTargets(): string;
  setBrowserTargets(value: string): void;

  getRerunTestGrep(): string;
  setRerunTestGrep(value: string): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TestCafeConfigResponse.AsObject;
  static toObject(includeInstance: boolean, msg: TestCafeConfigResponse): TestCafeConfigResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: TestCafeConfigResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TestCafeConfigResponse;
  static deserializeBinaryFromReader(message: TestCafeConfigResponse, reader: jspb.BinaryReader): TestCafeConfigResponse;
}

export namespace TestCafeConfigResponse {
  export type AsObject = {
    success: boolean,
    browserTargets: string,
    rerunTestGrep: string,
    error: string,
  }
}

export class PublishRunStateRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getScope(): string;
  setScope(value: string): void;

  getKey(): string;
  setKey(value: string): void;

  getTestRunUuid(): string;
  setTestRunUuid(value: string): void;

  getPayloadJson(): Uint8Array | string;
  getPayloadJson_asU8(): Uint8Array;
  getPayloadJson_asB64(): string;
  setPayloadJson(value: Uint8Array | string): void;

  getMode(): string;
  setMode(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  hasPlatformIndex(): boolean;
  clearPlatformIndex(): void;
  getPlatformIndex(): string;
  setPlatformIndex(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): PublishRunStateRequest.AsObject;
  static toObject(includeInstance: boolean, msg: PublishRunStateRequest): PublishRunStateRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: PublishRunStateRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): PublishRunStateRequest;
  static deserializeBinaryFromReader(message: PublishRunStateRequest, reader: jspb.BinaryReader): PublishRunStateRequest;
}

export namespace PublishRunStateRequest {
  export type AsObject = {
    binSessionId: string,
    scope: string,
    key: string,
    testRunUuid: string,
    payloadJson: Uint8Array | string,
    mode: string,
    clientWorkerId: string,
    platformIndex: string,
  }
}

export class PublishRunStateResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  getTruncated(): boolean;
  setTruncated(value: boolean): void;

  getTerminal(): boolean;
  setTerminal(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): PublishRunStateResponse.AsObject;
  static toObject(includeInstance: boolean, msg: PublishRunStateResponse): PublishRunStateResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: PublishRunStateResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): PublishRunStateResponse;
  static deserializeBinaryFromReader(message: PublishRunStateResponse, reader: jspb.BinaryReader): PublishRunStateResponse;
}

export namespace PublishRunStateResponse {
  export type AsObject = {
    success: boolean,
    error: string,
    truncated: boolean,
    terminal: boolean,
  }
}

export class FetchRunStateRequest extends jspb.Message {
  getBinSessionId(): string;
  setBinSessionId(value: string): void;

  getScope(): string;
  setScope(value: string): void;

  getKey(): string;
  setKey(value: string): void;

  getTestRunUuid(): string;
  setTestRunUuid(value: string): void;

  hasClientWorkerId(): boolean;
  clearClientWorkerId(): void;
  getClientWorkerId(): string;
  setClientWorkerId(value: string): void;

  hasPlatformIndex(): boolean;
  clearPlatformIndex(): void;
  getPlatformIndex(): string;
  setPlatformIndex(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): FetchRunStateRequest.AsObject;
  static toObject(includeInstance: boolean, msg: FetchRunStateRequest): FetchRunStateRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: FetchRunStateRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): FetchRunStateRequest;
  static deserializeBinaryFromReader(message: FetchRunStateRequest, reader: jspb.BinaryReader): FetchRunStateRequest;
}

export namespace FetchRunStateRequest {
  export type AsObject = {
    binSessionId: string,
    scope: string,
    key: string,
    testRunUuid: string,
    clientWorkerId: string,
    platformIndex: string,
  }
}

export class FetchRunStateResponse extends jspb.Message {
  getSuccess(): boolean;
  setSuccess(value: boolean): void;

  getFound(): boolean;
  setFound(value: boolean): void;

  getPayloadJson(): Uint8Array | string;
  getPayloadJson_asU8(): Uint8Array;
  getPayloadJson_asB64(): string;
  setPayloadJson(value: Uint8Array | string): void;

  hasError(): boolean;
  clearError(): void;
  getError(): string;
  setError(value: string): void;

  getTerminal(): boolean;
  setTerminal(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): FetchRunStateResponse.AsObject;
  static toObject(includeInstance: boolean, msg: FetchRunStateResponse): FetchRunStateResponse.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: FetchRunStateResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): FetchRunStateResponse;
  static deserializeBinaryFromReader(message: FetchRunStateResponse, reader: jspb.BinaryReader): FetchRunStateResponse;
}

export namespace FetchRunStateResponse {
  export type AsObject = {
    success: boolean,
    found: boolean,
    payloadJson: Uint8Array | string,
    error: string,
    terminal: boolean,
  }
}