clarifai-web-grpc 10.1.6 → 10.3.0

package/dist/esm/proto/clarifai/api/status/status_code_pb.js

@@ -90,6 +90,10 @@ proto.clarifai.api.status.StatusCode = {
     MODEL_NOT_DEPLOYED: 21353,
     MODEL_REFERENCE_INVALID_ARGUMENT: 21400,
     MODEL_EXAMPLE_INPUT_INVALID_ARGUMENT: 21420,
+    MODEL_EXPORTED: 21500,
+    MODEL_EXPORTING: 21501,
+    MODEL_EXPORTING_FAILED: 21502,
+    MODEL_EXPORT_PENDING: 21503,
     WORKFLOW_NO_MATCHING_INPUT: 22001,
     WORKFLOW_REQUIRE_TRAINED_MODEL: 22002,
     WORKFLOW_DUPLICATE: 22100,
@@ -303,6 +307,12 @@ proto.clarifai.api.status.StatusCode = {
     TASK_CONFLICT: 54100,
     TASK_NOT_IMPLEMENTED: 54101,
     TASK_MISSING: 54102,
+    TASK_PERMISSION_DENIED: 54103,
+    TASK_ASSIGNMENT_SUCCESS: 54200,
+    TASK_ASSIGNMENT_PENDING: 54201,
+    TASK_ASSIGNMENT_AWAITING_REVIEW: 54202,
+    TASK_ASSIGNMENT_AWAITING_CONSENSUS_REVIEW: 54203,
+    TASK_ASSIGNMENT_REVIEW_DENIED: 54204,
     LABEL_ORDER_PENDING: 55001,
     LABEL_ORDER_IN_PROGRESS: 55002,
     LABEL_ORDER_SUCCESS: 55003,

package/dist/esm/proto/clarifai/auth/scope/scope_pb.js

@@ -236,6 +236,8 @@ proto.clarifai.auth.scope.S = {
     MODELS_DELETE: 17,
     MODELS_TRAIN: 26,
     MODELS_SYNC: 27,
+    MODELEXPORTS_GET: 142,
+    MODELEXPORTS_ADD: 143,
     WORKFLOWS_ADD: 18,
     WORKFLOWS_GET: 19,
     WORKFLOWS_PATCH: 20,

package/dist/esm/resources.d.ts

@@ -1 +1,2 @@
 export * from './proto/clarifai/api/resources_pb';
+export { Struct } from 'google-protobuf/google/protobuf/struct_pb';

package/dist/esm/resources.js

@@ -1 +1,2 @@
 export * from './proto/clarifai/api/resources_pb';
+export { Struct } from 'google-protobuf/google/protobuf/struct_pb';

package/examples/post-app.ts

@@ -0,0 +1,27 @@
+import { ClarifaiStub } from '../index'
+import { App } from '../resources'
+import { PostAppsRequest } from '../service'
+
+export async function createAnApp() {
+  // get a client object
+  const client = ClarifaiStub.promise()
+
+  // create an app
+  const app = new App();
+  app.setId('cat-app');
+  app.setDefaultWorkflowId('General-Detection');
+  app.setDescription('An app for some cats');
+
+  // create a request
+  const req = new PostAppsRequest();
+  req.setAppsList([app]);
+
+  // send the request
+  const auth = {
+    authorization: `Key ${process.env.CLARIFAI_TOKEN}`,
+  };
+  const resp = await client.postApps(req, auth);
+
+  // log the app id
+  console.log(resp.getAppsList()[0].getId());
+}

package/examples/post-input.ts

@@ -0,0 +1,42 @@
+import { ClarifaiStub } from '../index'
+import { Struct, Data, Input, Text } from '../resources'
+import { PostInputsRequest } from '../service'
+
+export async function createAnInput() {
+  // create an input with some text. In a real app, this might come
+  // from a filepicker widget, or maybe a datasource like S3 or a database.
+  const input = new Input();
+
+  const data = new Data();
+
+  const text = new Text();
+  text.setRaw("hello world");
+
+  // we can also attach metadata to an input so we can correlate it with
+  // other data in our system. This can be any JSON-serializable object.
+  const metadata = Struct.fromJavaScript({
+    product_id: '1234',
+    location: 'San Francisco',
+    client: 'acme',
+  });
+
+  data.setMetadata(metadata);
+
+  input.setData(data);
+
+  // get a client object
+  const client = ClarifaiStub.promise()
+
+  // create a request
+  const req = new PostInputsRequest();
+  req.setInputsList([input]);
+
+  // send the request
+  const auth = {
+    authorization: `Key ${process.env.CLARIFAI_TOKEN}`,
+  };
+  const resp = await client.postInputs(req, auth);
+
+  // log the input id
+  console.log(resp.getInputsList()[0].getId());
+}

package/index.ts

@@ -1,12 +1,17 @@
 import { V2Client, V2PromiseClient } from './proto/clarifai/api/service_grpc_web_pb'
 
 export class ClarifaiStub {
-  static grpc (hostname = 'api.clarifai.com') {
+  static grpc (hostname = 'https://api-grpc-web.clarifai.com') {
     const options = { 'grpc.max_receive_message_length': 128 * 1024 * 1024 } // 128 MB
     return new V2Client(hostname, null, options)
   }
+
+  static promise (hostname = 'https://api-grpc-web.clarifai.com') {
+    const options = { 'grpc.max_receive_message_length': 128 * 1024 * 1024 } // 128 MB
+    return new V2PromiseClient(hostname, null, options)
+  }
 }
 
 export { V2Client, V2PromiseClient }
-export { RpcError, Metadata, ClientReadableStream } from 'grpc-web'
+export { RpcError, Metadata, ClientReadableStream, Request, UnaryResponse } from 'grpc-web'
 export { BaseResponse } from './proto/clarifai/api/status/status_pb'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarifai-web-grpc",
-  "version": "10.1.6",
+  "version": "10.3.0",
   "description": "The official Clarifai gRPC-web client",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",

package/proto/clarifai/api/resources_pb.d.ts

@@ -3330,6 +3330,16 @@ export class ModelVersion extends jspb.Message {
   getTrainLog(): string;
   setTrainLog(value: string): ModelVersion;
 
+  getInferenceComputeInfo(): ComputeInfo | undefined;
+  setInferenceComputeInfo(value?: ComputeInfo): ModelVersion;
+  hasInferenceComputeInfo(): boolean;
+  clearInferenceComputeInfo(): ModelVersion;
+
+  getBuildInfo(): BuildInfo | undefined;
+  setBuildInfo(value?: BuildInfo): ModelVersion;
+  hasBuildInfo(): boolean;
+  clearBuildInfo(): ModelVersion;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): ModelVersion.AsObject;
   static toObject(includeInstance: boolean, msg: ModelVersion): ModelVersion.AsObject;
@@ -3360,6 +3370,62 @@ export namespace ModelVersion {
     trainInfo?: TrainInfo.AsObject,
     importInfo?: ImportInfo.AsObject,
     trainLog: string,
+    inferenceComputeInfo?: ComputeInfo.AsObject,
+    buildInfo?: BuildInfo.AsObject,
+  }
+}
+
+export class BuildInfo extends jspb.Message {
+  getDockerImageName(): string;
+  setDockerImageName(value: string): BuildInfo;
+
+  getDockerImageTag(): string;
+  setDockerImageTag(value: string): BuildInfo;
+
+  getDockerImageDigest(): string;
+  setDockerImageDigest(value: string): BuildInfo;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): BuildInfo.AsObject;
+  static toObject(includeInstance: boolean, msg: BuildInfo): BuildInfo.AsObject;
+  static serializeBinaryToWriter(message: BuildInfo, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): BuildInfo;
+  static deserializeBinaryFromReader(message: BuildInfo, reader: jspb.BinaryReader): BuildInfo;
+}
+
+export namespace BuildInfo {
+  export type AsObject = {
+    dockerImageName: string,
+    dockerImageTag: string,
+    dockerImageDigest: string,
+  }
+}
+
+export class ModelVersionExport extends jspb.Message {
+  getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
+  setStatus(value?: proto_clarifai_api_status_status_pb.Status): ModelVersionExport;
+  hasStatus(): boolean;
+  clearStatus(): ModelVersionExport;
+
+  getUrl(): string;
+  setUrl(value: string): ModelVersionExport;
+
+  getSize(): number;
+  setSize(value: number): ModelVersionExport;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ModelVersionExport.AsObject;
+  static toObject(includeInstance: boolean, msg: ModelVersionExport): ModelVersionExport.AsObject;
+  static serializeBinaryToWriter(message: ModelVersionExport, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ModelVersionExport;
+  static deserializeBinaryFromReader(message: ModelVersionExport, reader: jspb.BinaryReader): ModelVersionExport;
+}
+
+export namespace ModelVersionExport {
+  export type AsObject = {
+    status?: proto_clarifai_api_status_status_pb.Status.AsObject,
+    url: string,
+    size: number,
   }
 }
 
@@ -3810,6 +3876,16 @@ export class EvalTestSetEntry extends jspb.Message {
   hasAnnotation(): boolean;
   clearAnnotation(): EvalTestSetEntry;
 
+  getPredictedAnnotation(): Annotation | undefined;
+  setPredictedAnnotation(value?: Annotation): EvalTestSetEntry;
+  hasPredictedAnnotation(): boolean;
+  clearPredictedAnnotation(): EvalTestSetEntry;
+
+  getGroundTruthAnnotation(): Annotation | undefined;
+  setGroundTruthAnnotation(value?: Annotation): EvalTestSetEntry;
+  hasGroundTruthAnnotation(): boolean;
+  clearGroundTruthAnnotation(): EvalTestSetEntry;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): EvalTestSetEntry.AsObject;
   static toObject(includeInstance: boolean, msg: EvalTestSetEntry): EvalTestSetEntry.AsObject;
@@ -3824,6 +3900,8 @@ export namespace EvalTestSetEntry {
     predictedConceptsList: Array<Concept.AsObject>,
     groundTruthConceptsList: Array<Concept.AsObject>,
     annotation?: Annotation.AsObject,
+    predictedAnnotation?: Annotation.AsObject,
+    groundTruthAnnotation?: Annotation.AsObject,
   }
 }
 
@@ -5664,21 +5742,16 @@ export class TaskWorker extends jspb.Message {
   clearUsersList(): TaskWorker;
   addUsers(value?: User, index?: number): User;
 
-  getModelsList(): Array<Model>;
-  setModelsList(value: Array<Model>): TaskWorker;
-  clearModelsList(): TaskWorker;
-  addModels(value?: Model, index?: number): Model;
-
-  getWorkflowsList(): Array<Workflow>;
-  setWorkflowsList(value: Array<Workflow>): TaskWorker;
-  clearWorkflowsList(): TaskWorker;
-  addWorkflows(value?: Workflow, index?: number): Workflow;
-
   getPartitionedStrategyInfo(): TaskWorkerPartitionedStrategyInfo | undefined;
   setPartitionedStrategyInfo(value?: TaskWorkerPartitionedStrategyInfo): TaskWorker;
   hasPartitionedStrategyInfo(): boolean;
   clearPartitionedStrategyInfo(): TaskWorker;
 
+  getWorkersList(): Array<Worker>;
+  setWorkersList(value: Array<Worker>): TaskWorker;
+  clearWorkersList(): TaskWorker;
+  addWorkers(value?: Worker, index?: number): Worker;
+
   getStrategyInfoCase(): TaskWorker.StrategyInfoCase;
 
   serializeBinary(): Uint8Array;
@@ -5694,9 +5767,8 @@ export namespace TaskWorker {
     strategy: TaskWorker.TaskWorkerStrategy,
     userIdsList: Array<string>,
     usersList: Array<User.AsObject>,
-    modelsList: Array<Model.AsObject>,
-    workflowsList: Array<Workflow.AsObject>,
     partitionedStrategyInfo?: TaskWorkerPartitionedStrategyInfo.AsObject,
+    workersList: Array<Worker.AsObject>,
   }
 
   export enum TaskWorkerStrategy { 
@@ -5885,6 +5957,54 @@ export namespace TaskAIAssistant {
   }
 }
 
+export class TaskAssignment extends jspb.Message {
+  getId(): string;
+  setId(value: string): TaskAssignment;
+
+  getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): TaskAssignment;
+  hasCreatedAt(): boolean;
+  clearCreatedAt(): TaskAssignment;
+
+  getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): TaskAssignment;
+  hasModifiedAt(): boolean;
+  clearModifiedAt(): TaskAssignment;
+
+  getWorker(): Worker | undefined;
+  setWorker(value?: Worker): TaskAssignment;
+  hasWorker(): boolean;
+  clearWorker(): TaskAssignment;
+
+  getInput(): Input | undefined;
+  setInput(value?: Input): TaskAssignment;
+  hasInput(): boolean;
+  clearInput(): TaskAssignment;
+
+  getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
+  setStatus(value?: proto_clarifai_api_status_status_pb.Status): TaskAssignment;
+  hasStatus(): boolean;
+  clearStatus(): TaskAssignment;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TaskAssignment.AsObject;
+  static toObject(includeInstance: boolean, msg: TaskAssignment): TaskAssignment.AsObject;
+  static serializeBinaryToWriter(message: TaskAssignment, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TaskAssignment;
+  static deserializeBinaryFromReader(message: TaskAssignment, reader: jspb.BinaryReader): TaskAssignment;
+}
+
+export namespace TaskAssignment {
+  export type AsObject = {
+    id: string,
+    createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    worker?: Worker.AsObject,
+    input?: Input.AsObject,
+    status?: proto_clarifai_api_status_status_pb.Status.AsObject,
+  }
+}
+
 export class TaskStatusCountPerUser extends jspb.Message {
   getUserId(): string;
   setUserId(value: string): TaskStatusCountPerUser;
@@ -6008,8 +6128,10 @@ export namespace TaskConcept {
 }
 
 export class TaskMetrics extends jspb.Message {
-  getEstimatedLabeledInputsCount(): number;
-  setEstimatedLabeledInputsCount(value: number): TaskMetrics;
+  getWork(): TaskWorkMetrics | undefined;
+  setWork(value?: TaskWorkMetrics): TaskMetrics;
+  hasWork(): boolean;
+  clearWork(): TaskMetrics;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): TaskMetrics.AsObject;
@@ -6021,7 +6143,29 @@ export class TaskMetrics extends jspb.Message {
 
 export namespace TaskMetrics {
   export type AsObject = {
-    estimatedLabeledInputsCount: number,
+    work?: TaskWorkMetrics.AsObject,
+  }
+}
+
+export class TaskWorkMetrics extends jspb.Message {
+  getInputsCountEstimated(): number;
+  setInputsCountEstimated(value: number): TaskWorkMetrics;
+
+  getInputsPercentEstimated(): number;
+  setInputsPercentEstimated(value: number): TaskWorkMetrics;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TaskWorkMetrics.AsObject;
+  static toObject(includeInstance: boolean, msg: TaskWorkMetrics): TaskWorkMetrics.AsObject;
+  static serializeBinaryToWriter(message: TaskWorkMetrics, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TaskWorkMetrics;
+  static deserializeBinaryFromReader(message: TaskWorkMetrics, reader: jspb.BinaryReader): TaskWorkMetrics;
+}
+
+export namespace TaskWorkMetrics {
+  export type AsObject = {
+    inputsCountEstimated: number,
+    inputsPercentEstimated: number,
   }
 }
 
@@ -7739,6 +7883,28 @@ export class Runner extends jspb.Message {
   clearLabelsList(): Runner;
   addLabels(value: string, index?: number): Runner;
 
+  getModel(): Model | undefined;
+  setModel(value?: Model): Runner;
+  hasModel(): boolean;
+  clearModel(): Runner;
+
+  getWorkflow(): Workflow | undefined;
+  setWorkflow(value?: Workflow): Runner;
+  hasWorkflow(): boolean;
+  clearWorkflow(): Runner;
+
+  getNodepool(): Nodepool | undefined;
+  setNodepool(value?: Nodepool): Runner;
+  hasNodepool(): boolean;
+  clearNodepool(): Runner;
+
+  getComputeInfo(): ComputeInfo | undefined;
+  setComputeInfo(value?: ComputeInfo): Runner;
+  hasComputeInfo(): boolean;
+  clearComputeInfo(): Runner;
+
+  getObjectCase(): Runner.ObjectCase;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): Runner.AsObject;
   static toObject(includeInstance: boolean, msg: Runner): Runner.AsObject;
@@ -7756,6 +7922,281 @@ export namespace Runner {
     metadata?: google_protobuf_struct_pb.Struct.AsObject,
     userId: string,
     labelsList: Array<string>,
+    model?: Model.AsObject,
+    workflow?: Workflow.AsObject,
+    nodepool?: Nodepool.AsObject,
+    computeInfo?: ComputeInfo.AsObject,
+  }
+
+  export enum ObjectCase { 
+    OBJECT_NOT_SET = 0,
+    MODEL = 9,
+    WORKFLOW = 10,
+  }
+}
+
+export class Nodepool extends jspb.Message {
+  getId(): string;
+  setId(value: string): Nodepool;
+
+  getUserId(): string;
+  setUserId(value: string): Nodepool;
+
+  getCloudRegion(): CloudRegion | undefined;
+  setCloudRegion(value?: CloudRegion): Nodepool;
+  hasCloudRegion(): boolean;
+  clearCloudRegion(): Nodepool;
+
+  getCapacityTypesList(): Array<Nodepool.CapacityType>;
+  setCapacityTypesList(value: Array<Nodepool.CapacityType>): Nodepool;
+  clearCapacityTypesList(): Nodepool;
+  addCapacityTypes(value: Nodepool.CapacityType, index?: number): Nodepool;
+
+  getInstanceTypesList(): Array<string>;
+  setInstanceTypesList(value: Array<string>): Nodepool;
+  clearInstanceTypesList(): Nodepool;
+  addInstanceTypes(value: string, index?: number): Nodepool;
+
+  getMinInstances(): number;
+  setMinInstances(value: number): Nodepool;
+
+  getMaxInstances(): number;
+  setMaxInstances(value: number): Nodepool;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Nodepool.AsObject;
+  static toObject(includeInstance: boolean, msg: Nodepool): Nodepool.AsObject;
+  static serializeBinaryToWriter(message: Nodepool, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Nodepool;
+  static deserializeBinaryFromReader(message: Nodepool, reader: jspb.BinaryReader): Nodepool;
+}
+
+export namespace Nodepool {
+  export type AsObject = {
+    id: string,
+    userId: string,
+    cloudRegion?: CloudRegion.AsObject,
+    capacityTypesList: Array<Nodepool.CapacityType>,
+    instanceTypesList: Array<string>,
+    minInstances: number,
+    maxInstances: number,
+  }
+
+  export enum CapacityType { 
+    UKNOWN_CAPACITY_TYPE = 0,
+    ONDEMAND_TYPE = 1,
+    SPOT_TYPE = 2,
+  }
+}
+
+export class CloudRegion extends jspb.Message {
+  getId(): string;
+  setId(value: string): CloudRegion;
+
+  getCloud(): CloudRegion.Cloud;
+  setCloud(value: CloudRegion.Cloud): CloudRegion;
+
+  getRegion(): string;
+  setRegion(value: string): CloudRegion;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CloudRegion.AsObject;
+  static toObject(includeInstance: boolean, msg: CloudRegion): CloudRegion.AsObject;
+  static serializeBinaryToWriter(message: CloudRegion, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CloudRegion;
+  static deserializeBinaryFromReader(message: CloudRegion, reader: jspb.BinaryReader): CloudRegion;
+}
+
+export namespace CloudRegion {
+  export type AsObject = {
+    id: string,
+    cloud: CloudRegion.Cloud,
+    region: string,
+  }
+
+  export enum Cloud { 
+    UNKOWN_CLOUD = 0,
+    SELF_HOSTED = 1,
+    AWS = 2,
+    GCP = 3,
+    AZURE = 4,
+    LAMBDA = 5,
+  }
+}
+
+export class ComputeInfo extends jspb.Message {
+  getNumCpus(): number;
+  setNumCpus(value: number): ComputeInfo;
+
+  getCpuMemory(): string;
+  setCpuMemory(value: string): ComputeInfo;
+
+  getNumAccelerators(): number;
+  setNumAccelerators(value: number): ComputeInfo;
+
+  getAcceleratorMemory(): string;
+  setAcceleratorMemory(value: string): ComputeInfo;
+
+  getAcceleratorTypeList(): Array<string>;
+  setAcceleratorTypeList(value: Array<string>): ComputeInfo;
+  clearAcceleratorTypeList(): ComputeInfo;
+  addAcceleratorType(value: string, index?: number): ComputeInfo;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ComputeInfo.AsObject;
+  static toObject(includeInstance: boolean, msg: ComputeInfo): ComputeInfo.AsObject;
+  static serializeBinaryToWriter(message: ComputeInfo, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ComputeInfo;
+  static deserializeBinaryFromReader(message: ComputeInfo, reader: jspb.BinaryReader): ComputeInfo;
+}
+
+export namespace ComputeInfo {
+  export type AsObject = {
+    numCpus: number,
+    cpuMemory: string,
+    numAccelerators: number,
+    acceleratorMemory: string,
+    acceleratorTypeList: Array<string>,
+  }
+}
+
+export class AutoscaleConfig extends jspb.Message {
+  getMinReplicas(): number;
+  setMinReplicas(value: number): AutoscaleConfig;
+
+  getMaxReplicas(): number;
+  setMaxReplicas(value: number): AutoscaleConfig;
+
+  getTrafficHistorySeconds(): number;
+  setTrafficHistorySeconds(value: number): AutoscaleConfig;
+
+  getScaleDownDelaySeconds(): number;
+  setScaleDownDelaySeconds(value: number): AutoscaleConfig;
+
+  getScaleUpDelaySeconds(): number;
+  setScaleUpDelaySeconds(value: number): AutoscaleConfig;
+
+  getEnablePacking(): boolean;
+  setEnablePacking(value: boolean): AutoscaleConfig;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AutoscaleConfig.AsObject;
+  static toObject(includeInstance: boolean, msg: AutoscaleConfig): AutoscaleConfig.AsObject;
+  static serializeBinaryToWriter(message: AutoscaleConfig, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AutoscaleConfig;
+  static deserializeBinaryFromReader(message: AutoscaleConfig, reader: jspb.BinaryReader): AutoscaleConfig;
+}
+
+export namespace AutoscaleConfig {
+  export type AsObject = {
+    minReplicas: number,
+    maxReplicas: number,
+    trafficHistorySeconds: number,
+    scaleDownDelaySeconds: number,
+    scaleUpDelaySeconds: number,
+    enablePacking: boolean,
+  }
+}
+
+export class Deployment extends jspb.Message {
+  getId(): string;
+  setId(value: string): Deployment;
+
+  getUserId(): string;
+  setUserId(value: string): Deployment;
+
+  getAutoscaleConfig(): AutoscaleConfig | undefined;
+  setAutoscaleConfig(value?: AutoscaleConfig): Deployment;
+  hasAutoscaleConfig(): boolean;
+  clearAutoscaleConfig(): Deployment;
+
+  getNodepoolsList(): Array<Nodepool>;
+  setNodepoolsList(value: Array<Nodepool>): Deployment;
+  clearNodepoolsList(): Deployment;
+  addNodepools(value?: Nodepool, index?: number): Nodepool;
+
+  getModel(): Model | undefined;
+  setModel(value?: Model): Deployment;
+  hasModel(): boolean;
+  clearModel(): Deployment;
+
+  getWorkflow(): Workflow | undefined;
+  setWorkflow(value?: Workflow): Deployment;
+  hasWorkflow(): boolean;
+  clearWorkflow(): Deployment;
+
+  getSchedulingChoice(): Deployment.SchedulingChoice;
+  setSchedulingChoice(value: Deployment.SchedulingChoice): Deployment;
+
+  getObjectCase(): Deployment.ObjectCase;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Deployment.AsObject;
+  static toObject(includeInstance: boolean, msg: Deployment): Deployment.AsObject;
+  static serializeBinaryToWriter(message: Deployment, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Deployment;
+  static deserializeBinaryFromReader(message: Deployment, reader: jspb.BinaryReader): Deployment;
+}
+
+export namespace Deployment {
+  export type AsObject = {
+    id: string,
+    userId: string,
+    autoscaleConfig?: AutoscaleConfig.AsObject,
+    nodepoolsList: Array<Nodepool.AsObject>,
+    model?: Model.AsObject,
+    workflow?: Workflow.AsObject,
+    schedulingChoice: Deployment.SchedulingChoice,
+  }
+
+  export enum SchedulingChoice { 
+    UNKNOWN_SCHEDULING_CHOICE = 0,
+    FAIL = 1,
+    RANDOM = 2,
+    PRICE = 3,
+    PERFORMANCE = 4,
+    NETWORK = 5,
+    UTILIZATION = 6,
+    PREFER_SPOT = 7,
+    PREFER_ONDEMAND = 8,
+  }
+
+  export enum ObjectCase { 
+    OBJECT_NOT_SET = 0,
+    MODEL = 5,
+    WORKFLOW = 6,
+  }
+}
+
+export class RunnerSelector extends jspb.Message {
+  getNodepool(): Nodepool | undefined;
+  setNodepool(value?: Nodepool): RunnerSelector;
+  hasNodepool(): boolean;
+  clearNodepool(): RunnerSelector;
+
+  getRunner(): Runner | undefined;
+  setRunner(value?: Runner): RunnerSelector;
+  hasRunner(): boolean;
+  clearRunner(): RunnerSelector;
+
+  getDeployment(): Deployment | undefined;
+  setDeployment(value?: Deployment): RunnerSelector;
+  hasDeployment(): boolean;
+  clearDeployment(): RunnerSelector;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RunnerSelector.AsObject;
+  static toObject(includeInstance: boolean, msg: RunnerSelector): RunnerSelector.AsObject;
+  static serializeBinaryToWriter(message: RunnerSelector, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RunnerSelector;
+  static deserializeBinaryFromReader(message: RunnerSelector, reader: jspb.BinaryReader): RunnerSelector;
+}
+
+export namespace RunnerSelector {
+  export type AsObject = {
+    nodepool?: Nodepool.AsObject,
+    runner?: Runner.AsObject,
+    deployment?: Deployment.AsObject,
   }
 }