// @generated by protoc-gen-es v1.10.0
// @generated from file robot/v1/robot.proto (package viam.robot.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, Duration, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage, Struct, Timestamp } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import type { ResourceSpans } from "../../opentelemetry/proto/trace/v1/trace_pb.js";
import type { LogEntry, PoseInFrame, ResourceName, Transform } from "../../common/v1/common_pb.js";

/**
 * @generated from enum viam.robot.v1.PeerConnectionType
 */
export declare enum PeerConnectionType {
  /**
   * @generated from enum value: PEER_CONNECTION_TYPE_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

  /**
   * @generated from enum value: PEER_CONNECTION_TYPE_GRPC = 1;
   */
  GRPC = 1,

  /**
   * @generated from enum value: PEER_CONNECTION_TYPE_WEBRTC = 2;
   */
  WEBRTC = 2,
}

/**
 * @generated from message viam.robot.v1.SendTracesRequest
 */
export declare class SendTracesRequest extends Message<SendTracesRequest> {
  /**
   * @generated from field: repeated opentelemetry.proto.trace.v1.ResourceSpans resource_spans = 1;
   */
  resourceSpans: ResourceSpans[];

  constructor(data?: PartialMessage<SendTracesRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.SendTracesRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendTracesRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendTracesRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendTracesRequest;

  static equals(a: SendTracesRequest | PlainMessage<SendTracesRequest> | undefined, b: SendTracesRequest | PlainMessage<SendTracesRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.SendTracesResponse
 */
export declare class SendTracesResponse extends Message<SendTracesResponse> {
  constructor(data?: PartialMessage<SendTracesResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.SendTracesResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendTracesResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendTracesResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendTracesResponse;

  static equals(a: SendTracesResponse | PlainMessage<SendTracesResponse> | undefined, b: SendTracesResponse | PlainMessage<SendTracesResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.TunnelRequest
 */
export declare class TunnelRequest extends Message<TunnelRequest> {
  /**
   * @generated from field: uint32 destination_port = 1;
   */
  destinationPort: number;

  /**
   * @generated from field: bytes data = 2;
   */
  data: Uint8Array;

  constructor(data?: PartialMessage<TunnelRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.TunnelRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TunnelRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TunnelRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TunnelRequest;

  static equals(a: TunnelRequest | PlainMessage<TunnelRequest> | undefined, b: TunnelRequest | PlainMessage<TunnelRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.TunnelResponse
 */
export declare class TunnelResponse extends Message<TunnelResponse> {
  /**
   * @generated from field: bytes data = 1;
   */
  data: Uint8Array;

  constructor(data?: PartialMessage<TunnelResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.TunnelResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TunnelResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TunnelResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TunnelResponse;

  static equals(a: TunnelResponse | PlainMessage<TunnelResponse> | undefined, b: TunnelResponse | PlainMessage<TunnelResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.ListTunnelsRequest
 */
export declare class ListTunnelsRequest extends Message<ListTunnelsRequest> {
  constructor(data?: PartialMessage<ListTunnelsRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ListTunnelsRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListTunnelsRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListTunnelsRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListTunnelsRequest;

  static equals(a: ListTunnelsRequest | PlainMessage<ListTunnelsRequest> | undefined, b: ListTunnelsRequest | PlainMessage<ListTunnelsRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.ListTunnelsResponse
 */
export declare class ListTunnelsResponse extends Message<ListTunnelsResponse> {
  /**
   * @generated from field: repeated viam.robot.v1.Tunnel tunnels = 1;
   */
  tunnels: Tunnel[];

  constructor(data?: PartialMessage<ListTunnelsResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ListTunnelsResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListTunnelsResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListTunnelsResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListTunnelsResponse;

  static equals(a: ListTunnelsResponse | PlainMessage<ListTunnelsResponse> | undefined, b: ListTunnelsResponse | PlainMessage<ListTunnelsResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.Tunnel
 */
export declare class Tunnel extends Message<Tunnel> {
  /**
   * @generated from field: uint32 port = 1;
   */
  port: number;

  /**
   * @generated from field: google.protobuf.Duration connection_timeout = 2;
   */
  connectionTimeout?: Duration;

  constructor(data?: PartialMessage<Tunnel>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.Tunnel";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Tunnel;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Tunnel;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Tunnel;

  static equals(a: Tunnel | PlainMessage<Tunnel> | undefined, b: Tunnel | PlainMessage<Tunnel> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.FrameSystemConfig
 */
export declare class FrameSystemConfig extends Message<FrameSystemConfig> {
  /**
   * this is an experimental API message
   *
   * @generated from field: viam.common.v1.Transform frame = 1;
   */
  frame?: Transform;

  /**
   * @generated from field: google.protobuf.Struct kinematics = 2;
   */
  kinematics?: Struct;

  constructor(data?: PartialMessage<FrameSystemConfig>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.FrameSystemConfig";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameSystemConfig;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameSystemConfig;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameSystemConfig;

  static equals(a: FrameSystemConfig | PlainMessage<FrameSystemConfig> | undefined, b: FrameSystemConfig | PlainMessage<FrameSystemConfig> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.FrameSystemConfigRequest
 */
export declare class FrameSystemConfigRequest extends Message<FrameSystemConfigRequest> {
  /**
   * pose information on any additional reference frames that are needed
   * to supplement the robot's frame system
   *
   * @generated from field: repeated viam.common.v1.Transform supplemental_transforms = 1;
   */
  supplementalTransforms: Transform[];

  constructor(data?: PartialMessage<FrameSystemConfigRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.FrameSystemConfigRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameSystemConfigRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameSystemConfigRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameSystemConfigRequest;

  static equals(a: FrameSystemConfigRequest | PlainMessage<FrameSystemConfigRequest> | undefined, b: FrameSystemConfigRequest | PlainMessage<FrameSystemConfigRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.FrameSystemConfigResponse
 */
export declare class FrameSystemConfigResponse extends Message<FrameSystemConfigResponse> {
  /**
   * @generated from field: repeated viam.robot.v1.FrameSystemConfig frame_system_configs = 1;
   */
  frameSystemConfigs: FrameSystemConfig[];

  constructor(data?: PartialMessage<FrameSystemConfigResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.FrameSystemConfigResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FrameSystemConfigResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FrameSystemConfigResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FrameSystemConfigResponse;

  static equals(a: FrameSystemConfigResponse | PlainMessage<FrameSystemConfigResponse> | undefined, b: FrameSystemConfigResponse | PlainMessage<FrameSystemConfigResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.TransformPoseRequest
 */
export declare class TransformPoseRequest extends Message<TransformPoseRequest> {
  /**
   * the original pose to transform along with the reference frame in
   * which it was observed
   *
   * @generated from field: viam.common.v1.PoseInFrame source = 1;
   */
  source?: PoseInFrame;

  /**
   * the reference frame into which the source pose should be transformed,
   * if unset this defaults to the "world" reference frame
   *
   * @generated from field: string destination = 2;
   */
  destination: string;

  /**
   * pose information on any additional reference frames that are needed
   * to perform the transform
   *
   * @generated from field: repeated viam.common.v1.Transform supplemental_transforms = 3;
   */
  supplementalTransforms: Transform[];

  constructor(data?: PartialMessage<TransformPoseRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.TransformPoseRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TransformPoseRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TransformPoseRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TransformPoseRequest;

  static equals(a: TransformPoseRequest | PlainMessage<TransformPoseRequest> | undefined, b: TransformPoseRequest | PlainMessage<TransformPoseRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.TransformPoseResponse
 */
export declare class TransformPoseResponse extends Message<TransformPoseResponse> {
  /**
   * @generated from field: viam.common.v1.PoseInFrame pose = 1;
   */
  pose?: PoseInFrame;

  constructor(data?: PartialMessage<TransformPoseResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.TransformPoseResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TransformPoseResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TransformPoseResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TransformPoseResponse;

  static equals(a: TransformPoseResponse | PlainMessage<TransformPoseResponse> | undefined, b: TransformPoseResponse | PlainMessage<TransformPoseResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.TransformPCDRequest
 */
export declare class TransformPCDRequest extends Message<TransformPCDRequest> {
  /**
   * the point clouds to transform. This should be in the PCD format,
   * [encoded into bytes](https://pointclouds.org/documentation/tutorials/pcd_file_format.html).
   *
   * @generated from field: bytes point_cloud_pcd = 1;
   */
  pointCloudPcd: Uint8Array;

  /**
   * the reference frame of the point cloud.
   *
   * @generated from field: string source = 2;
   */
  source: string;

  /**
   * the reference frame into which the source data should be transformed, if unset this defaults to the "world" reference frame.
   * Do not move the robot between the generation of the initial pointcloud and the receipt
   * of the transformed pointcloud because that will make the transformations inaccurate
   *
   * @generated from field: string destination = 3;
   */
  destination: string;

  constructor(data?: PartialMessage<TransformPCDRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.TransformPCDRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TransformPCDRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TransformPCDRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TransformPCDRequest;

  static equals(a: TransformPCDRequest | PlainMessage<TransformPCDRequest> | undefined, b: TransformPCDRequest | PlainMessage<TransformPCDRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.TransformPCDResponse
 */
export declare class TransformPCDResponse extends Message<TransformPCDResponse> {
  /**
   * @generated from field: bytes point_cloud_pcd = 1;
   */
  pointCloudPcd: Uint8Array;

  constructor(data?: PartialMessage<TransformPCDResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.TransformPCDResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TransformPCDResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TransformPCDResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TransformPCDResponse;

  static equals(a: TransformPCDResponse | PlainMessage<TransformPCDResponse> | undefined, b: TransformPCDResponse | PlainMessage<TransformPCDResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.ResourceNamesRequest
 */
export declare class ResourceNamesRequest extends Message<ResourceNamesRequest> {
  constructor(data?: PartialMessage<ResourceNamesRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ResourceNamesRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResourceNamesRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResourceNamesRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResourceNamesRequest;

  static equals(a: ResourceNamesRequest | PlainMessage<ResourceNamesRequest> | undefined, b: ResourceNamesRequest | PlainMessage<ResourceNamesRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.ResourceNamesResponse
 */
export declare class ResourceNamesResponse extends Message<ResourceNamesResponse> {
  /**
   * @generated from field: repeated viam.common.v1.ResourceName resources = 1;
   */
  resources: ResourceName[];

  constructor(data?: PartialMessage<ResourceNamesResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ResourceNamesResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResourceNamesResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResourceNamesResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResourceNamesResponse;

  static equals(a: ResourceNamesResponse | PlainMessage<ResourceNamesResponse> | undefined, b: ResourceNamesResponse | PlainMessage<ResourceNamesResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.ResourceRPCSubtype
 */
export declare class ResourceRPCSubtype extends Message<ResourceRPCSubtype> {
  /**
   * @generated from field: viam.common.v1.ResourceName subtype = 1;
   */
  subtype?: ResourceName;

  /**
   * @generated from field: string proto_service = 2;
   */
  protoService: string;

  constructor(data?: PartialMessage<ResourceRPCSubtype>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ResourceRPCSubtype";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResourceRPCSubtype;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResourceRPCSubtype;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResourceRPCSubtype;

  static equals(a: ResourceRPCSubtype | PlainMessage<ResourceRPCSubtype> | undefined, b: ResourceRPCSubtype | PlainMessage<ResourceRPCSubtype> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.ResourceRPCSubtypesRequest
 */
export declare class ResourceRPCSubtypesRequest extends Message<ResourceRPCSubtypesRequest> {
  constructor(data?: PartialMessage<ResourceRPCSubtypesRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ResourceRPCSubtypesRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResourceRPCSubtypesRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResourceRPCSubtypesRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResourceRPCSubtypesRequest;

  static equals(a: ResourceRPCSubtypesRequest | PlainMessage<ResourceRPCSubtypesRequest> | undefined, b: ResourceRPCSubtypesRequest | PlainMessage<ResourceRPCSubtypesRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.ResourceRPCSubtypesResponse
 */
export declare class ResourceRPCSubtypesResponse extends Message<ResourceRPCSubtypesResponse> {
  /**
   * @generated from field: repeated viam.robot.v1.ResourceRPCSubtype resource_rpc_subtypes = 1;
   */
  resourceRpcSubtypes: ResourceRPCSubtype[];

  constructor(data?: PartialMessage<ResourceRPCSubtypesResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ResourceRPCSubtypesResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResourceRPCSubtypesResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResourceRPCSubtypesResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResourceRPCSubtypesResponse;

  static equals(a: ResourceRPCSubtypesResponse | PlainMessage<ResourceRPCSubtypesResponse> | undefined, b: ResourceRPCSubtypesResponse | PlainMessage<ResourceRPCSubtypesResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.Operation
 */
export declare class Operation extends Message<Operation> {
  /**
   * @generated from field: string id = 1;
   */
  id: string;

  /**
   * @generated from field: string method = 2;
   */
  method: string;

  /**
   * @generated from field: google.protobuf.Struct arguments = 3;
   */
  arguments?: Struct;

  /**
   * @generated from field: google.protobuf.Timestamp started = 4;
   */
  started?: Timestamp;

  /**
   * @generated from field: optional string session_id = 5;
   */
  sessionId?: string;

  constructor(data?: PartialMessage<Operation>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.Operation";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Operation;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Operation;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Operation;

  static equals(a: Operation | PlainMessage<Operation> | undefined, b: Operation | PlainMessage<Operation> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetOperationsRequest
 */
export declare class GetOperationsRequest extends Message<GetOperationsRequest> {
  constructor(data?: PartialMessage<GetOperationsRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetOperationsRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetOperationsRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetOperationsRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetOperationsRequest;

  static equals(a: GetOperationsRequest | PlainMessage<GetOperationsRequest> | undefined, b: GetOperationsRequest | PlainMessage<GetOperationsRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetOperationsResponse
 */
export declare class GetOperationsResponse extends Message<GetOperationsResponse> {
  /**
   * @generated from field: repeated viam.robot.v1.Operation operations = 1;
   */
  operations: Operation[];

  constructor(data?: PartialMessage<GetOperationsResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetOperationsResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetOperationsResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetOperationsResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetOperationsResponse;

  static equals(a: GetOperationsResponse | PlainMessage<GetOperationsResponse> | undefined, b: GetOperationsResponse | PlainMessage<GetOperationsResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.CancelOperationRequest
 */
export declare class CancelOperationRequest extends Message<CancelOperationRequest> {
  /**
   * @generated from field: string id = 1;
   */
  id: string;

  constructor(data?: PartialMessage<CancelOperationRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.CancelOperationRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CancelOperationRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CancelOperationRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CancelOperationRequest;

  static equals(a: CancelOperationRequest | PlainMessage<CancelOperationRequest> | undefined, b: CancelOperationRequest | PlainMessage<CancelOperationRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.CancelOperationResponse
 */
export declare class CancelOperationResponse extends Message<CancelOperationResponse> {
  constructor(data?: PartialMessage<CancelOperationResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.CancelOperationResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CancelOperationResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CancelOperationResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CancelOperationResponse;

  static equals(a: CancelOperationResponse | PlainMessage<CancelOperationResponse> | undefined, b: CancelOperationResponse | PlainMessage<CancelOperationResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.BlockForOperationRequest
 */
export declare class BlockForOperationRequest extends Message<BlockForOperationRequest> {
  /**
   * @generated from field: string id = 1;
   */
  id: string;

  constructor(data?: PartialMessage<BlockForOperationRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.BlockForOperationRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BlockForOperationRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BlockForOperationRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BlockForOperationRequest;

  static equals(a: BlockForOperationRequest | PlainMessage<BlockForOperationRequest> | undefined, b: BlockForOperationRequest | PlainMessage<BlockForOperationRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.BlockForOperationResponse
 */
export declare class BlockForOperationResponse extends Message<BlockForOperationResponse> {
  constructor(data?: PartialMessage<BlockForOperationResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.BlockForOperationResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BlockForOperationResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BlockForOperationResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BlockForOperationResponse;

  static equals(a: BlockForOperationResponse | PlainMessage<BlockForOperationResponse> | undefined, b: BlockForOperationResponse | PlainMessage<BlockForOperationResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.PeerConnectionInfo
 */
export declare class PeerConnectionInfo extends Message<PeerConnectionInfo> {
  /**
   * @generated from field: viam.robot.v1.PeerConnectionType type = 1;
   */
  type: PeerConnectionType;

  /**
   * @generated from field: optional string remote_address = 2;
   */
  remoteAddress?: string;

  /**
   * @generated from field: optional string local_address = 3;
   */
  localAddress?: string;

  constructor(data?: PartialMessage<PeerConnectionInfo>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.PeerConnectionInfo";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PeerConnectionInfo;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PeerConnectionInfo;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PeerConnectionInfo;

  static equals(a: PeerConnectionInfo | PlainMessage<PeerConnectionInfo> | undefined, b: PeerConnectionInfo | PlainMessage<PeerConnectionInfo> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.Session
 */
export declare class Session extends Message<Session> {
  /**
   * @generated from field: string id = 1;
   */
  id: string;

  /**
   * @generated from field: optional viam.robot.v1.PeerConnectionInfo peer_connection_info = 2;
   */
  peerConnectionInfo?: PeerConnectionInfo;

  constructor(data?: PartialMessage<Session>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.Session";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Session;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Session;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Session;

  static equals(a: Session | PlainMessage<Session> | undefined, b: Session | PlainMessage<Session> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetSessionsRequest
 */
export declare class GetSessionsRequest extends Message<GetSessionsRequest> {
  constructor(data?: PartialMessage<GetSessionsRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetSessionsRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetSessionsRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetSessionsRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetSessionsRequest;

  static equals(a: GetSessionsRequest | PlainMessage<GetSessionsRequest> | undefined, b: GetSessionsRequest | PlainMessage<GetSessionsRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetSessionsResponse
 */
export declare class GetSessionsResponse extends Message<GetSessionsResponse> {
  /**
   * @generated from field: repeated viam.robot.v1.Session sessions = 1;
   */
  sessions: Session[];

  constructor(data?: PartialMessage<GetSessionsResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetSessionsResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetSessionsResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetSessionsResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetSessionsResponse;

  static equals(a: GetSessionsResponse | PlainMessage<GetSessionsResponse> | undefined, b: GetSessionsResponse | PlainMessage<GetSessionsResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.ModuleModel
 */
export declare class ModuleModel extends Message<ModuleModel> {
  /**
   * @generated from field: string module_name = 1;
   */
  moduleName: string;

  /**
   * @generated from field: string model = 2;
   */
  model: string;

  /**
   * @generated from field: string api = 3;
   */
  api: string;

  /**
   * @generated from field: bool from_local_module = 4;
   */
  fromLocalModule: boolean;

  constructor(data?: PartialMessage<ModuleModel>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ModuleModel";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ModuleModel;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ModuleModel;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ModuleModel;

  static equals(a: ModuleModel | PlainMessage<ModuleModel> | undefined, b: ModuleModel | PlainMessage<ModuleModel> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetModelsFromModulesRequest
 */
export declare class GetModelsFromModulesRequest extends Message<GetModelsFromModulesRequest> {
  constructor(data?: PartialMessage<GetModelsFromModulesRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetModelsFromModulesRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetModelsFromModulesRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetModelsFromModulesRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetModelsFromModulesRequest;

  static equals(a: GetModelsFromModulesRequest | PlainMessage<GetModelsFromModulesRequest> | undefined, b: GetModelsFromModulesRequest | PlainMessage<GetModelsFromModulesRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetModelsFromModulesResponse
 */
export declare class GetModelsFromModulesResponse extends Message<GetModelsFromModulesResponse> {
  /**
   * @generated from field: repeated viam.robot.v1.ModuleModel models = 1;
   */
  models: ModuleModel[];

  constructor(data?: PartialMessage<GetModelsFromModulesResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetModelsFromModulesResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetModelsFromModulesResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetModelsFromModulesResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetModelsFromModulesResponse;

  static equals(a: GetModelsFromModulesResponse | PlainMessage<GetModelsFromModulesResponse> | undefined, b: GetModelsFromModulesResponse | PlainMessage<GetModelsFromModulesResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.Status
 */
export declare class Status extends Message<Status> {
  /**
   * @generated from field: viam.common.v1.ResourceName name = 1;
   */
  name?: ResourceName;

  /**
   * @generated from field: google.protobuf.Struct status = 2;
   */
  status?: Struct;

  /**
   * @generated from field: google.protobuf.Timestamp last_reconfigured = 3;
   */
  lastReconfigured?: Timestamp;

  constructor(data?: PartialMessage<Status>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.Status";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Status;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Status;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Status;

  static equals(a: Status | PlainMessage<Status> | undefined, b: Status | PlainMessage<Status> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetStatusRequest
 */
export declare class GetStatusRequest extends Message<GetStatusRequest> {
  /**
   * @generated from field: repeated viam.common.v1.ResourceName resource_names = 1;
   */
  resourceNames: ResourceName[];

  constructor(data?: PartialMessage<GetStatusRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetStatusRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetStatusRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetStatusRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetStatusRequest;

  static equals(a: GetStatusRequest | PlainMessage<GetStatusRequest> | undefined, b: GetStatusRequest | PlainMessage<GetStatusRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetStatusResponse
 */
export declare class GetStatusResponse extends Message<GetStatusResponse> {
  /**
   * @generated from field: repeated viam.robot.v1.Status status = 1;
   */
  status: Status[];

  constructor(data?: PartialMessage<GetStatusResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetStatusResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetStatusResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetStatusResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetStatusResponse;

  static equals(a: GetStatusResponse | PlainMessage<GetStatusResponse> | undefined, b: GetStatusResponse | PlainMessage<GetStatusResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.StreamStatusRequest
 */
export declare class StreamStatusRequest extends Message<StreamStatusRequest> {
  /**
   * @generated from field: repeated viam.common.v1.ResourceName resource_names = 1;
   */
  resourceNames: ResourceName[];

  /**
   * how often to send a new status.
   *
   * @generated from field: google.protobuf.Duration every = 2;
   */
  every?: Duration;

  constructor(data?: PartialMessage<StreamStatusRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.StreamStatusRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamStatusRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamStatusRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamStatusRequest;

  static equals(a: StreamStatusRequest | PlainMessage<StreamStatusRequest> | undefined, b: StreamStatusRequest | PlainMessage<StreamStatusRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.StreamStatusResponse
 */
export declare class StreamStatusResponse extends Message<StreamStatusResponse> {
  /**
   * @generated from field: repeated viam.robot.v1.Status status = 1;
   */
  status: Status[];

  constructor(data?: PartialMessage<StreamStatusResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.StreamStatusResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamStatusResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamStatusResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamStatusResponse;

  static equals(a: StreamStatusResponse | PlainMessage<StreamStatusResponse> | undefined, b: StreamStatusResponse | PlainMessage<StreamStatusResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.StopExtraParameters
 */
export declare class StopExtraParameters extends Message<StopExtraParameters> {
  /**
   * @generated from field: viam.common.v1.ResourceName name = 1;
   */
  name?: ResourceName;

  /**
   * @generated from field: google.protobuf.Struct params = 2;
   */
  params?: Struct;

  constructor(data?: PartialMessage<StopExtraParameters>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.StopExtraParameters";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StopExtraParameters;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StopExtraParameters;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StopExtraParameters;

  static equals(a: StopExtraParameters | PlainMessage<StopExtraParameters> | undefined, b: StopExtraParameters | PlainMessage<StopExtraParameters> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.StopAllRequest
 */
export declare class StopAllRequest extends Message<StopAllRequest> {
  /**
   * @generated from field: repeated viam.robot.v1.StopExtraParameters extra = 99;
   */
  extra: StopExtraParameters[];

  constructor(data?: PartialMessage<StopAllRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.StopAllRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StopAllRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StopAllRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StopAllRequest;

  static equals(a: StopAllRequest | PlainMessage<StopAllRequest> | undefined, b: StopAllRequest | PlainMessage<StopAllRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.StopAllResponse
 */
export declare class StopAllResponse extends Message<StopAllResponse> {
  constructor(data?: PartialMessage<StopAllResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.StopAllResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StopAllResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StopAllResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StopAllResponse;

  static equals(a: StopAllResponse | PlainMessage<StopAllResponse> | undefined, b: StopAllResponse | PlainMessage<StopAllResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.StartSessionRequest
 */
export declare class StartSessionRequest extends Message<StartSessionRequest> {
  /**
   * resume can be used to attempt to continue a stream after a disconnection event. If
   * a session is not found, a new one will be created and returned.
   *
   * @generated from field: string resume = 1;
   */
  resume: string;

  constructor(data?: PartialMessage<StartSessionRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.StartSessionRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StartSessionRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StartSessionRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StartSessionRequest;

  static equals(a: StartSessionRequest | PlainMessage<StartSessionRequest> | undefined, b: StartSessionRequest | PlainMessage<StartSessionRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.StartSessionResponse
 */
export declare class StartSessionResponse extends Message<StartSessionResponse> {
  /**
   * @generated from field: string id = 1;
   */
  id: string;

  /**
   * @generated from field: google.protobuf.Duration heartbeat_window = 2;
   */
  heartbeatWindow?: Duration;

  constructor(data?: PartialMessage<StartSessionResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.StartSessionResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StartSessionResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StartSessionResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StartSessionResponse;

  static equals(a: StartSessionResponse | PlainMessage<StartSessionResponse> | undefined, b: StartSessionResponse | PlainMessage<StartSessionResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.SendSessionHeartbeatRequest
 */
export declare class SendSessionHeartbeatRequest extends Message<SendSessionHeartbeatRequest> {
  /**
   * @generated from field: string id = 1;
   */
  id: string;

  constructor(data?: PartialMessage<SendSessionHeartbeatRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.SendSessionHeartbeatRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendSessionHeartbeatRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendSessionHeartbeatRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendSessionHeartbeatRequest;

  static equals(a: SendSessionHeartbeatRequest | PlainMessage<SendSessionHeartbeatRequest> | undefined, b: SendSessionHeartbeatRequest | PlainMessage<SendSessionHeartbeatRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.SendSessionHeartbeatResponse
 */
export declare class SendSessionHeartbeatResponse extends Message<SendSessionHeartbeatResponse> {
  constructor(data?: PartialMessage<SendSessionHeartbeatResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.SendSessionHeartbeatResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendSessionHeartbeatResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendSessionHeartbeatResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendSessionHeartbeatResponse;

  static equals(a: SendSessionHeartbeatResponse | PlainMessage<SendSessionHeartbeatResponse> | undefined, b: SendSessionHeartbeatResponse | PlainMessage<SendSessionHeartbeatResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.LogRequest
 */
export declare class LogRequest extends Message<LogRequest> {
  /**
   * @generated from field: repeated viam.common.v1.LogEntry logs = 1;
   */
  logs: LogEntry[];

  constructor(data?: PartialMessage<LogRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.LogRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LogRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LogRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LogRequest;

  static equals(a: LogRequest | PlainMessage<LogRequest> | undefined, b: LogRequest | PlainMessage<LogRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.LogResponse
 */
export declare class LogResponse extends Message<LogResponse> {
  constructor(data?: PartialMessage<LogResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.LogResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LogResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LogResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LogResponse;

  static equals(a: LogResponse | PlainMessage<LogResponse> | undefined, b: LogResponse | PlainMessage<LogResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetCloudMetadataRequest
 */
export declare class GetCloudMetadataRequest extends Message<GetCloudMetadataRequest> {
  constructor(data?: PartialMessage<GetCloudMetadataRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetCloudMetadataRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetCloudMetadataRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetCloudMetadataRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetCloudMetadataRequest;

  static equals(a: GetCloudMetadataRequest | PlainMessage<GetCloudMetadataRequest> | undefined, b: GetCloudMetadataRequest | PlainMessage<GetCloudMetadataRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetCloudMetadataResponse
 */
export declare class GetCloudMetadataResponse extends Message<GetCloudMetadataResponse> {
  /**
   * @generated from field: string primary_org_id = 2;
   */
  primaryOrgId: string;

  /**
   * @generated from field: string location_id = 3;
   */
  locationId: string;

  /**
   * @generated from field: string machine_id = 4;
   */
  machineId: string;

  /**
   * @generated from field: string machine_part_id = 5;
   */
  machinePartId: string;

  constructor(data?: PartialMessage<GetCloudMetadataResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetCloudMetadataResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetCloudMetadataResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetCloudMetadataResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetCloudMetadataResponse;

  static equals(a: GetCloudMetadataResponse | PlainMessage<GetCloudMetadataResponse> | undefined, b: GetCloudMetadataResponse | PlainMessage<GetCloudMetadataResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.RestartModuleRequest
 */
export declare class RestartModuleRequest extends Message<RestartModuleRequest> {
  /**
   * @generated from oneof viam.robot.v1.RestartModuleRequest.id_or_name
   */
  idOrName: {
    /**
     * ID is for registry modules, name for local modules
     *
     * @generated from field: string module_id = 1;
     */
    value: string;
    case: "moduleId";
  } | {
    /**
     * @generated from field: string module_name = 2;
     */
    value: string;
    case: "moduleName";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<RestartModuleRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.RestartModuleRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RestartModuleRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RestartModuleRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RestartModuleRequest;

  static equals(a: RestartModuleRequest | PlainMessage<RestartModuleRequest> | undefined, b: RestartModuleRequest | PlainMessage<RestartModuleRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.RestartModuleResponse
 */
export declare class RestartModuleResponse extends Message<RestartModuleResponse> {
  constructor(data?: PartialMessage<RestartModuleResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.RestartModuleResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RestartModuleResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RestartModuleResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RestartModuleResponse;

  static equals(a: RestartModuleResponse | PlainMessage<RestartModuleResponse> | undefined, b: RestartModuleResponse | PlainMessage<RestartModuleResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.ShutdownRequest
 */
export declare class ShutdownRequest extends Message<ShutdownRequest> {
  constructor(data?: PartialMessage<ShutdownRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ShutdownRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ShutdownRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ShutdownRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ShutdownRequest;

  static equals(a: ShutdownRequest | PlainMessage<ShutdownRequest> | undefined, b: ShutdownRequest | PlainMessage<ShutdownRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.ShutdownResponse
 */
export declare class ShutdownResponse extends Message<ShutdownResponse> {
  constructor(data?: PartialMessage<ShutdownResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ShutdownResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ShutdownResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ShutdownResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ShutdownResponse;

  static equals(a: ShutdownResponse | PlainMessage<ShutdownResponse> | undefined, b: ShutdownResponse | PlainMessage<ShutdownResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetMachineStatusRequest
 */
export declare class GetMachineStatusRequest extends Message<GetMachineStatusRequest> {
  constructor(data?: PartialMessage<GetMachineStatusRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetMachineStatusRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetMachineStatusRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetMachineStatusRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetMachineStatusRequest;

  static equals(a: GetMachineStatusRequest | PlainMessage<GetMachineStatusRequest> | undefined, b: GetMachineStatusRequest | PlainMessage<GetMachineStatusRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetMachineStatusResponse
 */
export declare class GetMachineStatusResponse extends Message<GetMachineStatusResponse> {
  /**
   * @generated from field: repeated viam.robot.v1.ResourceStatus resources = 1;
   */
  resources: ResourceStatus[];

  /**
   * @generated from field: viam.robot.v1.ConfigStatus config = 2;
   */
  config?: ConfigStatus;

  /**
   * @generated from field: viam.robot.v1.GetMachineStatusResponse.State state = 3;
   */
  state: GetMachineStatusResponse_State;

  /**
   * @generated from field: repeated viam.robot.v1.JobStatus job_statuses = 4;
   */
  jobStatuses: JobStatus[];

  constructor(data?: PartialMessage<GetMachineStatusResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetMachineStatusResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetMachineStatusResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetMachineStatusResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetMachineStatusResponse;

  static equals(a: GetMachineStatusResponse | PlainMessage<GetMachineStatusResponse> | undefined, b: GetMachineStatusResponse | PlainMessage<GetMachineStatusResponse> | undefined): boolean;
}

/**
 * @generated from enum viam.robot.v1.GetMachineStatusResponse.State
 */
export declare enum GetMachineStatusResponse_State {
  /**
   * @generated from enum value: STATE_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

  /**
   * the machine is reachable but still in the process of configuring initial
   * modules and resources.
   *
   * @generated from enum value: STATE_INITIALIZING = 1;
   */
  INITIALIZING = 1,

  /**
   * the machine has finished initializing.
   *
   * @generated from enum value: STATE_RUNNING = 2;
   */
  RUNNING = 2,
}

/**
 * @generated from message viam.robot.v1.JobStatus
 */
export declare class JobStatus extends Message<JobStatus> {
  /**
   * @generated from field: string job_name = 1;
   */
  jobName: string;

  /**
   * @generated from field: repeated google.protobuf.Timestamp recent_successful_runs = 2;
   */
  recentSuccessfulRuns: Timestamp[];

  /**
   * @generated from field: repeated google.protobuf.Timestamp recent_failed_runs = 3;
   */
  recentFailedRuns: Timestamp[];

  constructor(data?: PartialMessage<JobStatus>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.JobStatus";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobStatus;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobStatus;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobStatus;

  static equals(a: JobStatus | PlainMessage<JobStatus> | undefined, b: JobStatus | PlainMessage<JobStatus> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.ResourceStatus
 */
export declare class ResourceStatus extends Message<ResourceStatus> {
  /**
   * resource name.
   *
   * @generated from field: viam.common.v1.ResourceName name = 1;
   */
  name?: ResourceName;

  /**
   * current state.
   *
   * @generated from field: viam.robot.v1.ResourceStatus.State state = 2;
   */
  state: ResourceStatus_State;

  /**
   * state transition timestamp.
   *
   * @generated from field: google.protobuf.Timestamp last_updated = 3;
   */
  lastUpdated?: Timestamp;

  /**
   * revision of the last config that successfully updated this resource.
   *
   * @generated from field: string revision = 4;
   */
  revision: string;

  /**
   * error details for a resource. This is guaranteed to be null if the
   * resource is ready and non-null if the resource unhealthy.
   *
   * @generated from field: string error = 5;
   */
  error: string;

  /**
   * infomation about resource orgID, locationID and partID
   *
   * @generated from field: optional viam.robot.v1.GetCloudMetadataResponse cloud_metadata = 6;
   */
  cloudMetadata?: GetCloudMetadataResponse;

  constructor(data?: PartialMessage<ResourceStatus>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ResourceStatus";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResourceStatus;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResourceStatus;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResourceStatus;

  static equals(a: ResourceStatus | PlainMessage<ResourceStatus> | undefined, b: ResourceStatus | PlainMessage<ResourceStatus> | undefined): boolean;
}

/**
 * @generated from enum viam.robot.v1.ResourceStatus.State
 */
export declare enum ResourceStatus_State {
  /**
   * @generated from enum value: STATE_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

  /**
   * a newly created resource.
   *
   * @generated from enum value: STATE_UNCONFIGURED = 1;
   */
  UNCONFIGURED = 1,

  /**
   * a resource that is being configured.
   *
   * @generated from enum value: STATE_CONFIGURING = 2;
   */
  CONFIGURING = 2,

  /**
   * a resource that has been successfully configured once, and is not re-configuring,
   * being removed, or unhealthy.
   *
   * @generated from enum value: STATE_READY = 3;
   */
  READY = 3,

  /**
   * a resource that is being removed from the robot.
   *
   * @generated from enum value: STATE_REMOVING = 4;
   */
  REMOVING = 4,

  /**
   * a resource that is in an unhealthy state.
   *
   * @generated from enum value: STATE_UNHEALTHY = 5;
   */
  UNHEALTHY = 5,
}

/**
 * @generated from message viam.robot.v1.ConfigStatus
 */
export declare class ConfigStatus extends Message<ConfigStatus> {
  /**
   * revision of the last config that the machine successfully ingested.
   *
   * @generated from field: string revision = 1;
   */
  revision: string;

  /**
   * config ingestion timestamp.
   *
   * @generated from field: google.protobuf.Timestamp last_updated = 2;
   */
  lastUpdated?: Timestamp;

  constructor(data?: PartialMessage<ConfigStatus>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.ConfigStatus";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConfigStatus;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConfigStatus;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConfigStatus;

  static equals(a: ConfigStatus | PlainMessage<ConfigStatus> | undefined, b: ConfigStatus | PlainMessage<ConfigStatus> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetVersionRequest
 */
export declare class GetVersionRequest extends Message<GetVersionRequest> {
  constructor(data?: PartialMessage<GetVersionRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetVersionRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetVersionRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetVersionRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetVersionRequest;

  static equals(a: GetVersionRequest | PlainMessage<GetVersionRequest> | undefined, b: GetVersionRequest | PlainMessage<GetVersionRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetVersionResponse
 */
export declare class GetVersionResponse extends Message<GetVersionResponse> {
  /**
   * platform type of viam-server (ie. `rdk` or `micro-rdk`).
   *
   * @generated from field: string platform = 1;
   */
  platform: string;

  /**
   * version of viam-server. If built without a version, it will be dev-<git hash>.
   *
   * @generated from field: string version = 2;
   */
  version: string;

  /**
   * @generated from field: string api_version = 3;
   */
  apiVersion: string;

  constructor(data?: PartialMessage<GetVersionResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetVersionResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetVersionResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetVersionResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetVersionResponse;

  static equals(a: GetVersionResponse | PlainMessage<GetVersionResponse> | undefined, b: GetVersionResponse | PlainMessage<GetVersionResponse> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetPoseRequest
 */
export declare class GetPoseRequest extends Message<GetPoseRequest> {
  /**
   * the component whose pose is being requested
   *
   * @generated from field: string component_name = 1;
   */
  componentName: string;

  /**
   * the reference frame in which the component's pose
   * should be provided, if unset this defaults
   * to the "world" reference frame
   *
   * @generated from field: string destination_frame = 2;
   */
  destinationFrame: string;

  /**
   * pose information on any additional reference frames that are needed
   * to compute the component's pose
   *
   * @generated from field: repeated viam.common.v1.Transform supplemental_transforms = 3;
   */
  supplementalTransforms: Transform[];

  /**
   * Additional arguments to the method
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<GetPoseRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetPoseRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetPoseRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetPoseRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetPoseRequest;

  static equals(a: GetPoseRequest | PlainMessage<GetPoseRequest> | undefined, b: GetPoseRequest | PlainMessage<GetPoseRequest> | undefined): boolean;
}

/**
 * @generated from message viam.robot.v1.GetPoseResponse
 */
export declare class GetPoseResponse extends Message<GetPoseResponse> {
  /**
   * @generated from field: viam.common.v1.PoseInFrame pose = 1;
   */
  pose?: PoseInFrame;

  constructor(data?: PartialMessage<GetPoseResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.robot.v1.GetPoseResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetPoseResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetPoseResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetPoseResponse;

  static equals(a: GetPoseResponse | PlainMessage<GetPoseResponse> | undefined, b: GetPoseResponse | PlainMessage<GetPoseResponse> | undefined): boolean;
}