clarifai-web-grpc 5.0.0 → 9.6.1

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

@@ -1,6 +1,7 @@
 import * as jspb from 'google-protobuf'
 
 import * as proto_clarifai_api_status_status_pb from '../../../proto/clarifai/api/status/status_pb';
+import * as proto_clarifai_api_status_status_code_pb from '../../../proto/clarifai/api/status/status_code_pb';
 import * as proto_clarifai_api_utils_extensions_pb from '../../../proto/clarifai/api/utils/extensions_pb';
 import * as proto_clarifai_api_utils_matrix_pb from '../../../proto/clarifai/api/utils/matrix_pb';
 import * as proto_clarifai_auth_util_extension_pb from '../../../proto/clarifai/auth/util/extension_pb';
@@ -104,6 +105,11 @@ export class App extends jspb.Message {
   getDefaultWorkflowId(): string;
   setDefaultWorkflowId(value: string): App;
 
+  getDefaultWorkflow(): Workflow | undefined;
+  setDefaultWorkflow(value?: Workflow): App;
+  hasDefaultWorkflow(): boolean;
+  clearDefaultWorkflow(): App;
+
   getUserId(): string;
   setUserId(value: string): App;
 
@@ -148,6 +154,11 @@ export class App extends jspb.Message {
   getNotes(): string;
   setNotes(value: string): App;
 
+  getImage(): Image | undefined;
+  setImage(value?: Image): App;
+  hasImage(): boolean;
+  clearImage(): App;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): App.AsObject;
   static toObject(includeInstance: boolean, msg: App): App.AsObject;
@@ -162,6 +173,7 @@ export namespace App {
     name: string,
     defaultLanguage: string,
     defaultWorkflowId: string,
+    defaultWorkflow?: Workflow.AsObject,
     userId: string,
     createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
     modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
@@ -174,6 +186,7 @@ export namespace App {
     isStarred: boolean,
     starCount: number,
     notes: string,
+    image?: Image.AsObject,
   }
 }
 
@@ -1584,6 +1597,26 @@ export namespace Input {
   }
 }
 
+export class InputBatch extends jspb.Message {
+  getInputsList(): Array<Input>;
+  setInputsList(value: Array<Input>): InputBatch;
+  clearInputsList(): InputBatch;
+  addInputs(value?: Input, index?: number): Input;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): InputBatch.AsObject;
+  static toObject(includeInstance: boolean, msg: InputBatch): InputBatch.AsObject;
+  static serializeBinaryToWriter(message: InputBatch, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): InputBatch;
+  static deserializeBinaryFromReader(message: InputBatch, reader: jspb.BinaryReader): InputBatch;
+}
+
+export namespace InputBatch {
+  export type AsObject = {
+    inputsList: Array<Input.AsObject>,
+  }
+}
+
 export class InputCount extends jspb.Message {
   getProcessed(): number;
   setProcessed(value: number): InputCount;
@@ -1676,6 +1709,12 @@ export class Dataset extends jspb.Message {
   hasVersion(): boolean;
   clearVersion(): Dataset;
 
+  getIsStarred(): boolean;
+  setIsStarred(value: boolean): Dataset;
+
+  getStarCount(): number;
+  setStarCount(value: number): Dataset;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): Dataset.AsObject;
   static toObject(includeInstance: boolean, msg: Dataset): Dataset.AsObject;
@@ -1697,6 +1736,8 @@ export namespace Dataset {
     defaultAnnotationFilter?: AnnotationFilter.AsObject,
     notes: string,
     version?: DatasetVersion.AsObject,
+    isStarred: boolean,
+    starCount: number,
   }
 }
 
@@ -1811,6 +1852,11 @@ export class DatasetVersion extends jspb.Message {
   getDescription(): string;
   setDescription(value: string): DatasetVersion;
 
+  getProcessingInfo(): DatasetVersionProcessingInfo | undefined;
+  setProcessingInfo(value?: DatasetVersionProcessingInfo): DatasetVersion;
+  hasProcessingInfo(): boolean;
+  clearProcessingInfo(): DatasetVersion;
+
   getMetricsMap(): jspb.Map<string, DatasetVersionMetrics>;
   clearMetricsMap(): DatasetVersion;
 
@@ -1856,6 +1902,7 @@ export namespace DatasetVersion {
     modelPredictConfig?: ModelPredictConfig.AsObject,
     status?: proto_clarifai_api_status_status_pb.Status.AsObject,
     description: string,
+    processingInfo?: DatasetVersionProcessingInfo.AsObject,
     metricsMap: Array<[string, DatasetVersionMetrics.AsObject]>,
     exportInfo?: DatasetVersionExportInfo.AsObject,
     metadata?: google_protobuf_struct_pb.Struct.AsObject,
@@ -1876,6 +1923,9 @@ export class AnnotationFilterConfig extends jspb.Message {
   hasAnnotationFilter(): boolean;
   clearAnnotationFilter(): AnnotationFilterConfig;
 
+  getIgnoreEmptyInputs(): boolean;
+  setIgnoreEmptyInputs(value: boolean): AnnotationFilterConfig;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): AnnotationFilterConfig.AsObject;
   static toObject(includeInstance: boolean, msg: AnnotationFilterConfig): AnnotationFilterConfig.AsObject;
@@ -1887,6 +1937,7 @@ export class AnnotationFilterConfig extends jspb.Message {
 export namespace AnnotationFilterConfig {
   export type AsObject = {
     annotationFilter?: AnnotationFilter.AsObject,
+    ignoreEmptyInputs: boolean,
   }
 }
 
@@ -2113,6 +2164,9 @@ export class DatasetVersionExport extends jspb.Message {
   getSize(): number;
   setSize(value: number): DatasetVersionExport;
 
+  getIncludeEmbeddings(): boolean;
+  setIncludeEmbeddings(value: boolean): DatasetVersionExport;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): DatasetVersionExport.AsObject;
   static toObject(includeInstance: boolean, msg: DatasetVersionExport): DatasetVersionExport.AsObject;
@@ -2127,6 +2181,45 @@ export namespace DatasetVersionExport {
     status?: proto_clarifai_api_status_status_pb.Status.AsObject,
     url: string,
     size: number,
+    includeEmbeddings: boolean,
+  }
+}
+
+export class DatasetVersionProcessingInfo extends jspb.Message {
+  getFrameInterpolationInfo(): FrameInterpolationInfo | undefined;
+  setFrameInterpolationInfo(value?: FrameInterpolationInfo): DatasetVersionProcessingInfo;
+  hasFrameInterpolationInfo(): boolean;
+  clearFrameInterpolationInfo(): DatasetVersionProcessingInfo;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DatasetVersionProcessingInfo.AsObject;
+  static toObject(includeInstance: boolean, msg: DatasetVersionProcessingInfo): DatasetVersionProcessingInfo.AsObject;
+  static serializeBinaryToWriter(message: DatasetVersionProcessingInfo, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DatasetVersionProcessingInfo;
+  static deserializeBinaryFromReader(message: DatasetVersionProcessingInfo, reader: jspb.BinaryReader): DatasetVersionProcessingInfo;
+}
+
+export namespace DatasetVersionProcessingInfo {
+  export type AsObject = {
+    frameInterpolationInfo?: FrameInterpolationInfo.AsObject,
+  }
+}
+
+export class FrameInterpolationInfo extends jspb.Message {
+  getSampleMs(): number;
+  setSampleMs(value: number): FrameInterpolationInfo;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): FrameInterpolationInfo.AsObject;
+  static toObject(includeInstance: boolean, msg: FrameInterpolationInfo): FrameInterpolationInfo.AsObject;
+  static serializeBinaryToWriter(message: FrameInterpolationInfo, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): FrameInterpolationInfo;
+  static deserializeBinaryFromReader(message: FrameInterpolationInfo, reader: jspb.BinaryReader): FrameInterpolationInfo;
+}
+
+export namespace FrameInterpolationInfo {
+  export type AsObject = {
+    sampleMs: number,
   }
 }
 
@@ -2586,9 +2679,6 @@ export class OutputConfig extends jspb.Message {
   getConceptsMutuallyExclusive(): boolean;
   setConceptsMutuallyExclusive(value: boolean): OutputConfig;
 
-  getClosedEnvironment(): boolean;
-  setClosedEnvironment(value: boolean): OutputConfig;
-
   getExistingModelId(): string;
   setExistingModelId(value: string): OutputConfig;
 
@@ -2642,7 +2732,6 @@ export class OutputConfig extends jspb.Message {
 export namespace OutputConfig {
   export type AsObject = {
     conceptsMutuallyExclusive: boolean,
-    closedEnvironment: boolean,
     existingModelId: string,
     language: string,
     hyperParameters: string,
@@ -2695,9 +2784,6 @@ export class ModelType extends jspb.Message {
   getRequiresSequentialFrames(): boolean;
   setRequiresSequentialFrames(value: boolean): ModelType;
 
-  getEvaluable(): boolean;
-  setEvaluable(value: boolean): ModelType;
-
   getExpectedInputLayersList(): Array<ModelLayerInfo>;
   setExpectedInputLayersList(value: Array<ModelLayerInfo>): ModelType;
   clearExpectedInputLayersList(): ModelType;
@@ -2708,6 +2794,9 @@ export class ModelType extends jspb.Message {
   clearExpectedOutputLayersList(): ModelType;
   addExpectedOutputLayers(value?: ModelLayerInfo, index?: number): ModelLayerInfo;
 
+  getEvaluationType(): EvaluationType;
+  setEvaluationType(value: EvaluationType): ModelType;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): ModelType.AsObject;
   static toObject(includeInstance: boolean, msg: ModelType): ModelType.AsObject;
@@ -2728,9 +2817,9 @@ export namespace ModelType {
     internalOnly: boolean,
     modelTypeFieldsList: Array<ModelTypeField.AsObject>,
     requiresSequentialFrames: boolean,
-    evaluable: boolean,
     expectedInputLayersList: Array<ModelLayerInfo.AsObject>,
     expectedOutputLayersList: Array<ModelLayerInfo.AsObject>,
+    evaluationType: EvaluationType,
   }
 }
 
@@ -2766,6 +2855,28 @@ export namespace ModelLayerInfo {
   }
 }
 
+export class TritonCondaEnvInfo extends jspb.Message {
+  getCondaPackUrl(): string;
+  setCondaPackUrl(value: string): TritonCondaEnvInfo;
+
+  getCondaYamlUrl(): string;
+  setCondaYamlUrl(value: string): TritonCondaEnvInfo;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TritonCondaEnvInfo.AsObject;
+  static toObject(includeInstance: boolean, msg: TritonCondaEnvInfo): TritonCondaEnvInfo.AsObject;
+  static serializeBinaryToWriter(message: TritonCondaEnvInfo, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TritonCondaEnvInfo;
+  static deserializeBinaryFromReader(message: TritonCondaEnvInfo, reader: jspb.BinaryReader): TritonCondaEnvInfo;
+}
+
+export namespace TritonCondaEnvInfo {
+  export type AsObject = {
+    condaPackUrl: string,
+    condaYamlUrl: string,
+  }
+}
+
 export class LayerShape extends jspb.Message {
   getDimsList(): Array<number>;
   setDimsList(value: Array<number>): LayerShape;
@@ -2922,6 +3033,9 @@ export class ModelTypeEnumOption extends jspb.Message {
   getInternalOnly(): boolean;
   setInternalOnly(value: boolean): ModelTypeEnumOption;
 
+  getRecommended(): boolean;
+  setRecommended(value: boolean): ModelTypeEnumOption;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): ModelTypeEnumOption.AsObject;
   static toObject(includeInstance: boolean, msg: ModelTypeEnumOption): ModelTypeEnumOption.AsObject;
@@ -2937,6 +3051,7 @@ export namespace ModelTypeEnumOption {
     description: string,
     modelTypeFieldsList: Array<ModelTypeField.AsObject>,
     internalOnly: boolean,
+    recommended: boolean,
   }
 }
 
@@ -3046,10 +3161,28 @@ export class ModelVersion extends jspb.Message {
   getLicense(): string;
   setLicense(value: string): ModelVersion;
 
-  getDatasetVersion(): DatasetVersion | undefined;
-  setDatasetVersion(value?: DatasetVersion): ModelVersion;
-  hasDatasetVersion(): boolean;
-  clearDatasetVersion(): ModelVersion;
+  getOutputInfo(): OutputInfo | undefined;
+  setOutputInfo(value?: OutputInfo): ModelVersion;
+  hasOutputInfo(): boolean;
+  clearOutputInfo(): ModelVersion;
+
+  getInputInfo(): InputInfo | undefined;
+  setInputInfo(value?: InputInfo): ModelVersion;
+  hasInputInfo(): boolean;
+  clearInputInfo(): ModelVersion;
+
+  getTrainInfo(): TrainInfo | undefined;
+  setTrainInfo(value?: TrainInfo): ModelVersion;
+  hasTrainInfo(): boolean;
+  clearTrainInfo(): ModelVersion;
+
+  getImportInfo(): ImportInfo | undefined;
+  setImportInfo(value?: ImportInfo): ModelVersion;
+  hasImportInfo(): boolean;
+  clearImportInfo(): ModelVersion;
+
+  getTrainLog(): string;
+  setTrainLog(value: string): ModelVersion;
 
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): ModelVersion.AsObject;
@@ -3076,7 +3209,11 @@ export namespace ModelVersion {
     modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
     metadata?: google_protobuf_struct_pb.Struct.AsObject,
     license: string,
-    datasetVersion?: DatasetVersion.AsObject,
+    outputInfo?: OutputInfo.AsObject,
+    inputInfo?: InputInfo.AsObject,
+    trainInfo?: TrainInfo.AsObject,
+    importInfo?: ImportInfo.AsObject,
+    trainLog: string,
   }
 }
 
@@ -3489,12 +3626,6 @@ export namespace TrackerMetrics {
 }
 
 export class EvalTestSetEntry extends jspb.Message {
-  getId(): string;
-  setId(value: string): EvalTestSetEntry;
-
-  getUrl(): string;
-  setUrl(value: string): EvalTestSetEntry;
-
   getInput(): Input | undefined;
   setInput(value?: Input): EvalTestSetEntry;
   hasInput(): boolean;
@@ -3525,8 +3656,6 @@ export class EvalTestSetEntry extends jspb.Message {
 
 export namespace EvalTestSetEntry {
   export type AsObject = {
-    id: string,
-    url: string,
     input?: Input.AsObject,
     predictedConceptsList: Array<Concept.AsObject>,
     groundTruthConceptsList: Array<Concept.AsObject>,
@@ -3638,9 +3767,25 @@ export class EvalMetrics extends jspb.Message {
   hasStatus(): boolean;
   clearStatus(): EvalMetrics;
 
+  getUserId(): string;
+  setUserId(value: string): EvalMetrics;
+
+  getAppId(): string;
+  setAppId(value: string): EvalMetrics;
+
   getId(): string;
   setId(value: string): EvalMetrics;
 
+  getModel(): Model | undefined;
+  setModel(value?: Model): EvalMetrics;
+  hasModel(): boolean;
+  clearModel(): EvalMetrics;
+
+  getGroundTruthDataset(): Dataset | undefined;
+  setGroundTruthDataset(value?: Dataset): EvalMetrics;
+  hasGroundTruthDataset(): boolean;
+  clearGroundTruthDataset(): EvalMetrics;
+
   getSummary(): MetricsSummary | undefined;
   setSummary(value?: MetricsSummary): EvalMetrics;
   hasSummary(): boolean;
@@ -3702,7 +3847,11 @@ export class EvalMetrics extends jspb.Message {
 export namespace EvalMetrics {
   export type AsObject = {
     status?: proto_clarifai_api_status_status_pb.Status.AsObject,
+    userId: string,
+    appId: string,
     id: string,
+    model?: Model.AsObject,
+    groundTruthDataset?: Dataset.AsObject,
     summary?: MetricsSummary.AsObject,
     confusionMatrix?: ConfusionMatrix.AsObject,
     cooccurrenceMatrix?: CooccurrenceMatrix.AsObject,
@@ -3892,6 +4041,24 @@ export namespace Hit {
   }
 }
 
+export class HitCount extends jspb.Message {
+  getEstimatedTotal(): number;
+  setEstimatedTotal(value: number): HitCount;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): HitCount.AsObject;
+  static toObject(includeInstance: boolean, msg: HitCount): HitCount.AsObject;
+  static serializeBinaryToWriter(message: HitCount, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): HitCount;
+  static deserializeBinaryFromReader(message: HitCount, reader: jspb.BinaryReader): HitCount;
+}
+
+export namespace HitCount {
+  export type AsObject = {
+    estimatedTotal: number,
+  }
+}
+
 export class And extends jspb.Message {
   getInput(): Input | undefined;
   setInput(value?: Input): And;
@@ -4011,6 +4178,9 @@ export class Search extends jspb.Message {
   hasVisibility(): boolean;
   clearVisibility(): Search;
 
+  getMetric(): Search.Metric;
+  setMetric(value: Search.Metric): Search;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): Search.AsObject;
   static toObject(includeInstance: boolean, msg: Search): Search.AsObject;
@@ -4033,6 +4203,13 @@ export namespace Search {
     save: boolean,
     minValue: number,
     visibility?: Visibility.AsObject,
+    metric: Search.Metric,
+  }
+
+  export enum Metric { 
+    METRIC_NOT_SET = 0,
+    EUCLIDEAN_DISTANCE = 1,
+    COSINE_DISTANCE = 2,
   }
 }
 
@@ -4795,6 +4972,11 @@ export class WorkflowNode extends jspb.Message {
   getSuppressOutput(): boolean;
   setSuppressOutput(value: boolean): WorkflowNode;
 
+  getOutputInfoOverride(): OutputInfo | undefined;
+  setOutputInfoOverride(value?: OutputInfo): WorkflowNode;
+  hasOutputInfoOverride(): boolean;
+  clearOutputInfoOverride(): WorkflowNode;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): WorkflowNode.AsObject;
   static toObject(includeInstance: boolean, msg: WorkflowNode): WorkflowNode.AsObject;
@@ -4809,6 +4991,7 @@ export namespace WorkflowNode {
     model?: Model.AsObject,
     nodeInputsList: Array<NodeInput.AsObject>,
     suppressOutput: boolean,
+    outputInfoOverride?: OutputInfo.AsObject,
   }
 }
 
@@ -5157,6 +5340,14 @@ export class Task extends jspb.Message {
   getLabelOrderId(): string;
   setLabelOrderId(value: string): Task;
 
+  getConceptsList(): Array<TaskConcept>;
+  setConceptsList(value: Array<TaskConcept>): Task;
+  clearConceptsList(): Task;
+  addConcepts(value?: TaskConcept, index?: number): TaskConcept;
+
+  getDeletePreviousAnnotations(): boolean;
+  setDeletePreviousAnnotations(value: boolean): Task;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): Task.AsObject;
   static toObject(includeInstance: boolean, msg: Task): Task.AsObject;
@@ -5185,6 +5376,8 @@ export namespace Task {
     appId: string,
     userId: string,
     labelOrderId: string,
+    conceptsList: Array<TaskConcept.AsObject>,
+    deletePreviousAnnotations: boolean,
   }
 
   export enum TaskType { 
@@ -5237,6 +5430,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;
@@ -5257,6 +5460,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,
   }
 
@@ -5484,6 +5689,90 @@ export namespace TaskStatusCountPerUser {
   }
 }
 
+export class ThresholdRange extends jspb.Message {
+  getIsLowerInclusive(): boolean;
+  setIsLowerInclusive(value: boolean): ThresholdRange;
+
+  getIsUpperInclusive(): boolean;
+  setIsUpperInclusive(value: boolean): ThresholdRange;
+
+  getLower(): number;
+  setLower(value: number): ThresholdRange;
+
+  getUpper(): number;
+  setUpper(value: number): ThresholdRange;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ThresholdRange.AsObject;
+  static toObject(includeInstance: boolean, msg: ThresholdRange): ThresholdRange.AsObject;
+  static serializeBinaryToWriter(message: ThresholdRange, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ThresholdRange;
+  static deserializeBinaryFromReader(message: ThresholdRange, reader: jspb.BinaryReader): ThresholdRange;
+}
+
+export namespace ThresholdRange {
+  export type AsObject = {
+    isLowerInclusive: boolean,
+    isUpperInclusive: boolean,
+    lower: number,
+    upper: number,
+  }
+}
+
+export class TaskConceptAutoAnnotationConfig extends jspb.Message {
+  getAnnotationDataTypes(): number;
+  setAnnotationDataTypes(value: number): TaskConceptAutoAnnotationConfig;
+
+  getThresholdRange(): ThresholdRange | undefined;
+  setThresholdRange(value?: ThresholdRange): TaskConceptAutoAnnotationConfig;
+  hasThresholdRange(): boolean;
+  clearThresholdRange(): TaskConceptAutoAnnotationConfig;
+
+  getStatusCode(): proto_clarifai_api_status_status_code_pb.StatusCode;
+  setStatusCode(value: proto_clarifai_api_status_status_code_pb.StatusCode): TaskConceptAutoAnnotationConfig;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TaskConceptAutoAnnotationConfig.AsObject;
+  static toObject(includeInstance: boolean, msg: TaskConceptAutoAnnotationConfig): TaskConceptAutoAnnotationConfig.AsObject;
+  static serializeBinaryToWriter(message: TaskConceptAutoAnnotationConfig, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TaskConceptAutoAnnotationConfig;
+  static deserializeBinaryFromReader(message: TaskConceptAutoAnnotationConfig, reader: jspb.BinaryReader): TaskConceptAutoAnnotationConfig;
+}
+
+export namespace TaskConceptAutoAnnotationConfig {
+  export type AsObject = {
+    annotationDataTypes: number,
+    thresholdRange?: ThresholdRange.AsObject,
+    statusCode: proto_clarifai_api_status_status_code_pb.StatusCode,
+  }
+}
+
+export class TaskConcept extends jspb.Message {
+  getConcept(): Concept | undefined;
+  setConcept(value?: Concept): TaskConcept;
+  hasConcept(): boolean;
+  clearConcept(): TaskConcept;
+
+  getAutoAnnotationConfig(): TaskConceptAutoAnnotationConfig | undefined;
+  setAutoAnnotationConfig(value?: TaskConceptAutoAnnotationConfig): TaskConcept;
+  hasAutoAnnotationConfig(): boolean;
+  clearAutoAnnotationConfig(): TaskConcept;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): TaskConcept.AsObject;
+  static toObject(includeInstance: boolean, msg: TaskConcept): TaskConcept.AsObject;
+  static serializeBinaryToWriter(message: TaskConcept, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): TaskConcept;
+  static deserializeBinaryFromReader(message: TaskConcept, reader: jspb.BinaryReader): TaskConcept;
+}
+
+export namespace TaskConcept {
+  export type AsObject = {
+    concept?: Concept.AsObject,
+    autoAnnotationConfig?: TaskConceptAutoAnnotationConfig.AsObject,
+  }
+}
+
 export class Collector extends jspb.Message {
   getId(): string;
   setId(value: string): Collector;
@@ -5768,6 +6057,52 @@ export namespace DatasetInputsSearchAddJob {
   }
 }
 
+export class PCAProjectionComparator extends jspb.Message {
+  getDistanceThreshold(): number;
+  setDistanceThreshold(value: number): PCAProjectionComparator;
+
+  getModelVersionId(): string;
+  setModelVersionId(value: string): PCAProjectionComparator;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PCAProjectionComparator.AsObject;
+  static toObject(includeInstance: boolean, msg: PCAProjectionComparator): PCAProjectionComparator.AsObject;
+  static serializeBinaryToWriter(message: PCAProjectionComparator, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PCAProjectionComparator;
+  static deserializeBinaryFromReader(message: PCAProjectionComparator, reader: jspb.BinaryReader): PCAProjectionComparator;
+}
+
+export namespace PCAProjectionComparator {
+  export type AsObject = {
+    distanceThreshold: number,
+    modelVersionId: string,
+  }
+}
+
+export class DuplicateAnnotationsResults extends jspb.Message {
+  getDuplicateCfidList(): Array<string>;
+  setDuplicateCfidList(value: Array<string>): DuplicateAnnotationsResults;
+  clearDuplicateCfidList(): DuplicateAnnotationsResults;
+  addDuplicateCfid(value: string, index?: number): DuplicateAnnotationsResults;
+
+  getUniqueCount(): number;
+  setUniqueCount(value: number): DuplicateAnnotationsResults;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DuplicateAnnotationsResults.AsObject;
+  static toObject(includeInstance: boolean, msg: DuplicateAnnotationsResults): DuplicateAnnotationsResults.AsObject;
+  static serializeBinaryToWriter(message: DuplicateAnnotationsResults, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DuplicateAnnotationsResults;
+  static deserializeBinaryFromReader(message: DuplicateAnnotationsResults, reader: jspb.BinaryReader): DuplicateAnnotationsResults;
+}
+
+export namespace DuplicateAnnotationsResults {
+  export type AsObject = {
+    duplicateCfidList: Array<string>,
+    uniqueCount: number,
+  }
+}
+
 export class Visibility extends jspb.Message {
   getGettable(): Visibility.Gettable;
   setGettable(value: Visibility.Gettable): Visibility;
@@ -5901,6 +6236,42 @@ export namespace TimeInfo {
   }
 }
 
+export class DatasetStar extends jspb.Message {
+  getDatasetId(): string;
+  setDatasetId(value: string): DatasetStar;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DatasetStar.AsObject;
+  static toObject(includeInstance: boolean, msg: DatasetStar): DatasetStar.AsObject;
+  static serializeBinaryToWriter(message: DatasetStar, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DatasetStar;
+  static deserializeBinaryFromReader(message: DatasetStar, reader: jspb.BinaryReader): DatasetStar;
+}
+
+export namespace DatasetStar {
+  export type AsObject = {
+    datasetId: string,
+  }
+}
+
+export class ModuleStar extends jspb.Message {
+  getModuleId(): string;
+  setModuleId(value: string): ModuleStar;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ModuleStar.AsObject;
+  static toObject(includeInstance: boolean, msg: ModuleStar): ModuleStar.AsObject;
+  static serializeBinaryToWriter(message: ModuleStar, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ModuleStar;
+  static deserializeBinaryFromReader(message: ModuleStar, reader: jspb.BinaryReader): ModuleStar;
+}
+
+export namespace ModuleStar {
+  export type AsObject = {
+    moduleId: string,
+  }
+}
+
 export class Module extends jspb.Message {
   getId(): string;
   setId(value: string): Module;
@@ -5934,6 +6305,17 @@ export class Module extends jspb.Message {
   getAppId(): string;
   setAppId(value: string): Module;
 
+  getModuleVersion(): ModuleVersion | undefined;
+  setModuleVersion(value?: ModuleVersion): Module;
+  hasModuleVersion(): boolean;
+  clearModuleVersion(): Module;
+
+  getIsStarred(): boolean;
+  setIsStarred(value: boolean): Module;
+
+  getStarCount(): number;
+  setStarCount(value: number): Module;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): Module.AsObject;
   static toObject(includeInstance: boolean, msg: Module): Module.AsObject;
@@ -5952,6 +6334,9 @@ export namespace Module {
     metadata?: google_protobuf_struct_pb.Struct.AsObject,
     userId: string,
     appId: string,
+    moduleVersion?: ModuleVersion.AsObject,
+    isStarred: boolean,
+    starCount: number,
   }
 }
 
@@ -6155,6 +6540,11 @@ export class BulkOperation extends jspb.Message {
   hasSearch(): boolean;
   clearSearch(): BulkOperation;
 
+  getDataset(): Dataset | undefined;
+  setDataset(value?: Dataset): BulkOperation;
+  hasDataset(): boolean;
+  clearDataset(): BulkOperation;
+
   getOperation(): Operation | undefined;
   setOperation(value?: Operation): BulkOperation;
   hasOperation(): boolean;
@@ -6201,6 +6591,7 @@ export namespace BulkOperation {
     id: string,
     inputIds?: InputIDs.AsObject,
     search?: Search.AsObject,
+    dataset?: Dataset.AsObject,
     operation?: Operation.AsObject,
     appId: string,
     status?: proto_clarifai_api_status_status_pb.Status.AsObject,
@@ -6214,6 +6605,7 @@ export namespace BulkOperation {
     INPUT_SOURCE_NOT_SET = 0,
     INPUT_IDS = 2,
     SEARCH = 10,
+    DATASET = 11,
   }
 }
 
@@ -6290,6 +6682,21 @@ export class Operation extends jspb.Message {
   hasDeleteGeo(): boolean;
   clearDeleteGeo(): Operation;
 
+  getDeleteFromDataset(): DeleteFromDataset | undefined;
+  setDeleteFromDataset(value?: DeleteFromDataset): Operation;
+  hasDeleteFromDataset(): boolean;
+  clearDeleteFromDataset(): Operation;
+
+  getAddToDataset(): AddToDataset | undefined;
+  setAddToDataset(value?: AddToDataset): Operation;
+  hasAddToDataset(): boolean;
+  clearAddToDataset(): Operation;
+
+  getSplitIntoDatasets(): SplitIntoDatasets | undefined;
+  setSplitIntoDatasets(value?: SplitIntoDatasets): Operation;
+  hasSplitIntoDatasets(): boolean;
+  clearSplitIntoDatasets(): Operation;
+
   getOperationCase(): Operation.OperationCase;
 
   serializeBinary(): Uint8Array;
@@ -6308,6 +6715,9 @@ export namespace Operation {
     deleteMetadata?: DeleteMetadata.AsObject,
     overwriteGeo?: OverwriteGeo.AsObject,
     deleteGeo?: DeleteGeo.AsObject,
+    deleteFromDataset?: DeleteFromDataset.AsObject,
+    addToDataset?: AddToDataset.AsObject,
+    splitIntoDatasets?: SplitIntoDatasets.AsObject,
   }
 
   export enum OperationCase { 
@@ -6318,6 +6728,9 @@ export namespace Operation {
     DELETE_METADATA = 4,
     OVERWRITE_GEO = 5,
     DELETE_GEO = 6,
+    DELETE_FROM_DATASET = 7,
+    ADD_TO_DATASET = 8,
+    SPLIT_INTO_DATASETS = 9,
   }
 }
 
@@ -6347,6 +6760,11 @@ export class DeleteConcepts extends jspb.Message {
   clearConceptsList(): DeleteConcepts;
   addConcepts(value?: Concept, index?: number): Concept;
 
+  getUserIdsList(): Array<string>;
+  setUserIdsList(value: Array<string>): DeleteConcepts;
+  clearUserIdsList(): DeleteConcepts;
+  addUserIds(value: string, index?: number): DeleteConcepts;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): DeleteConcepts.AsObject;
   static toObject(includeInstance: boolean, msg: DeleteConcepts): DeleteConcepts.AsObject;
@@ -6358,6 +6776,7 @@ export class DeleteConcepts extends jspb.Message {
 export namespace DeleteConcepts {
   export type AsObject = {
     conceptsList: Array<Concept.AsObject>,
+    userIdsList: Array<string>,
   }
 }
 
@@ -6435,13 +6854,106 @@ export namespace DeleteGeo {
   }
 }
 
+export class AddToDataset extends jspb.Message {
+  getDatasetId(): string;
+  setDatasetId(value: string): AddToDataset;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AddToDataset.AsObject;
+  static toObject(includeInstance: boolean, msg: AddToDataset): AddToDataset.AsObject;
+  static serializeBinaryToWriter(message: AddToDataset, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AddToDataset;
+  static deserializeBinaryFromReader(message: AddToDataset, reader: jspb.BinaryReader): AddToDataset;
+}
+
+export namespace AddToDataset {
+  export type AsObject = {
+    datasetId: string,
+  }
+}
+
+export class DeleteFromDataset extends jspb.Message {
+  getDatasetId(): string;
+  setDatasetId(value: string): DeleteFromDataset;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DeleteFromDataset.AsObject;
+  static toObject(includeInstance: boolean, msg: DeleteFromDataset): DeleteFromDataset.AsObject;
+  static serializeBinaryToWriter(message: DeleteFromDataset, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DeleteFromDataset;
+  static deserializeBinaryFromReader(message: DeleteFromDataset, reader: jspb.BinaryReader): DeleteFromDataset;
+}
+
+export namespace DeleteFromDataset {
+  export type AsObject = {
+    datasetId: string,
+  }
+}
+
+export class SplitIntoDatasets extends jspb.Message {
+  getDatasetSplitsList(): Array<DatasetSplit>;
+  setDatasetSplitsList(value: Array<DatasetSplit>): SplitIntoDatasets;
+  clearDatasetSplitsList(): SplitIntoDatasets;
+  addDatasetSplits(value?: DatasetSplit, index?: number): DatasetSplit;
+
+  getMethod(): SplitIntoDatasets.DatasetSplitMethod;
+  setMethod(value: SplitIntoDatasets.DatasetSplitMethod): SplitIntoDatasets;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SplitIntoDatasets.AsObject;
+  static toObject(includeInstance: boolean, msg: SplitIntoDatasets): SplitIntoDatasets.AsObject;
+  static serializeBinaryToWriter(message: SplitIntoDatasets, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SplitIntoDatasets;
+  static deserializeBinaryFromReader(message: SplitIntoDatasets, reader: jspb.BinaryReader): SplitIntoDatasets;
+}
+
+export namespace SplitIntoDatasets {
+  export type AsObject = {
+    datasetSplitsList: Array<DatasetSplit.AsObject>,
+    method: SplitIntoDatasets.DatasetSplitMethod,
+  }
+
+  export enum DatasetSplitMethod { 
+    NOT_SET = 0,
+    RANDOM_PERCENTAGE_SPLIT = 1,
+  }
+}
+
+export class DatasetSplit extends jspb.Message {
+  getDataset(): Dataset | undefined;
+  setDataset(value?: Dataset): DatasetSplit;
+  hasDataset(): boolean;
+  clearDataset(): DatasetSplit;
+
+  getPercentage(): number;
+  setPercentage(value: number): DatasetSplit;
+
+  getMethodInfoCase(): DatasetSplit.MethodInfoCase;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DatasetSplit.AsObject;
+  static toObject(includeInstance: boolean, msg: DatasetSplit): DatasetSplit.AsObject;
+  static serializeBinaryToWriter(message: DatasetSplit, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DatasetSplit;
+  static deserializeBinaryFromReader(message: DatasetSplit, reader: jspb.BinaryReader): DatasetSplit;
+}
+
+export namespace DatasetSplit {
+  export type AsObject = {
+    dataset?: Dataset.AsObject,
+    percentage: number,
+  }
+
+  export enum MethodInfoCase { 
+    METHOD_INFO_NOT_SET = 0,
+    PERCENTAGE = 2,
+  }
+}
+
 export class InputsAddJob extends jspb.Message {
   getId(): string;
   setId(value: string): InputsAddJob;
 
-  getCloudStorageUrl(): string;
-  setCloudStorageUrl(value: string): InputsAddJob;
-
   getCallBackUrl(): string;
   setCallBackUrl(value: string): InputsAddJob;
 
@@ -6463,6 +6975,21 @@ export class InputsAddJob extends jspb.Message {
   hasModifiedAt(): boolean;
   clearModifiedAt(): InputsAddJob;
 
+  getExtractionJobsList(): Array<InputsExtractionJob>;
+  setExtractionJobsList(value: Array<InputsExtractionJob>): InputsAddJob;
+  clearExtractionJobsList(): InputsAddJob;
+  addExtractionJobs(value?: InputsExtractionJob, index?: number): InputsExtractionJob;
+
+  getUploadsList(): Array<Upload>;
+  setUploadsList(value: Array<Upload>): InputsAddJob;
+  clearUploadsList(): InputsAddJob;
+  addUploads(value?: Upload, index?: number): Upload;
+
+  getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
+  setStatus(value?: proto_clarifai_api_status_status_pb.Status): InputsAddJob;
+  hasStatus(): boolean;
+  clearStatus(): InputsAddJob;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): InputsAddJob.AsObject;
   static toObject(includeInstance: boolean, msg: InputsAddJob): InputsAddJob.AsObject;
@@ -6474,12 +7001,14 @@ export class InputsAddJob extends jspb.Message {
 export namespace InputsAddJob {
   export type AsObject = {
     id: string,
-    cloudStorageUrl: string,
     callBackUrl: string,
     appPat: string,
     progress?: InputsAddJobProgress.AsObject,
     createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
     modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    extractionJobsList: Array<InputsExtractionJob.AsObject>,
+    uploadsList: Array<Upload.AsObject>,
+    status?: proto_clarifai_api_status_status_pb.Status.AsObject,
   }
 }
 
@@ -6595,6 +7124,305 @@ export namespace UploadContentPart {
   }
 }
 
+export class CustomCodeOperatorRequest extends jspb.Message {
+  getInputsList(): Array<Input>;
+  setInputsList(value: Array<Input>): CustomCodeOperatorRequest;
+  clearInputsList(): CustomCodeOperatorRequest;
+  addInputs(value?: Input, index?: number): Input;
+
+  getMetadata(): google_protobuf_struct_pb.Struct | undefined;
+  setMetadata(value?: google_protobuf_struct_pb.Struct): CustomCodeOperatorRequest;
+  hasMetadata(): boolean;
+  clearMetadata(): CustomCodeOperatorRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CustomCodeOperatorRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: CustomCodeOperatorRequest): CustomCodeOperatorRequest.AsObject;
+  static serializeBinaryToWriter(message: CustomCodeOperatorRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CustomCodeOperatorRequest;
+  static deserializeBinaryFromReader(message: CustomCodeOperatorRequest, reader: jspb.BinaryReader): CustomCodeOperatorRequest;
+}
+
+export namespace CustomCodeOperatorRequest {
+  export type AsObject = {
+    inputsList: Array<Input.AsObject>,
+    metadata?: google_protobuf_struct_pb.Struct.AsObject,
+  }
+}
+
+export class InputsExtractionJob extends jspb.Message {
+  getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
+  setStatus(value?: proto_clarifai_api_status_status_pb.Status): InputsExtractionJob;
+  hasStatus(): boolean;
+  clearStatus(): InputsExtractionJob;
+
+  getId(): string;
+  setId(value: string): InputsExtractionJob;
+
+  getUrl(): string;
+  setUrl(value: string): InputsExtractionJob;
+
+  getProgress(): InputsExtractionJobProgress | undefined;
+  setProgress(value?: InputsExtractionJobProgress): InputsExtractionJob;
+  hasProgress(): boolean;
+  clearProgress(): InputsExtractionJob;
+
+  getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): InputsExtractionJob;
+  hasCreatedAt(): boolean;
+  clearCreatedAt(): InputsExtractionJob;
+
+  getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): InputsExtractionJob;
+  hasModifiedAt(): boolean;
+  clearModifiedAt(): InputsExtractionJob;
+
+  getInputIdConflictResolution(): InputIDConflictResolution;
+  setInputIdConflictResolution(value: InputIDConflictResolution): InputsExtractionJob;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): InputsExtractionJob.AsObject;
+  static toObject(includeInstance: boolean, msg: InputsExtractionJob): InputsExtractionJob.AsObject;
+  static serializeBinaryToWriter(message: InputsExtractionJob, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): InputsExtractionJob;
+  static deserializeBinaryFromReader(message: InputsExtractionJob, reader: jspb.BinaryReader): InputsExtractionJob;
+}
+
+export namespace InputsExtractionJob {
+  export type AsObject = {
+    status?: proto_clarifai_api_status_status_pb.Status.AsObject,
+    id: string,
+    url: string,
+    progress?: InputsExtractionJobProgress.AsObject,
+    createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    inputIdConflictResolution: InputIDConflictResolution,
+  }
+}
+
+export class InputsExtractionJobProgress extends jspb.Message {
+  getAudioInputsCount(): number;
+  setAudioInputsCount(value: number): InputsExtractionJobProgress;
+
+  getImageInputsCount(): number;
+  setImageInputsCount(value: number): InputsExtractionJobProgress;
+
+  getVideoInputsCount(): number;
+  setVideoInputsCount(value: number): InputsExtractionJobProgress;
+
+  getTextInputsCount(): number;
+  setTextInputsCount(value: number): InputsExtractionJobProgress;
+
+  getPendingArchivesCount(): number;
+  setPendingArchivesCount(value: number): InputsExtractionJobProgress;
+
+  getInProgressArchivesCount(): number;
+  setInProgressArchivesCount(value: number): InputsExtractionJobProgress;
+
+  getCompletedArchivesCount(): number;
+  setCompletedArchivesCount(value: number): InputsExtractionJobProgress;
+
+  getFailedArchivesCount(): number;
+  setFailedArchivesCount(value: number): InputsExtractionJobProgress;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): InputsExtractionJobProgress.AsObject;
+  static toObject(includeInstance: boolean, msg: InputsExtractionJobProgress): InputsExtractionJobProgress.AsObject;
+  static serializeBinaryToWriter(message: InputsExtractionJobProgress, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): InputsExtractionJobProgress;
+  static deserializeBinaryFromReader(message: InputsExtractionJobProgress, reader: jspb.BinaryReader): InputsExtractionJobProgress;
+}
+
+export namespace InputsExtractionJobProgress {
+  export type AsObject = {
+    audioInputsCount: number,
+    imageInputsCount: number,
+    videoInputsCount: number,
+    textInputsCount: number,
+    pendingArchivesCount: number,
+    inProgressArchivesCount: number,
+    completedArchivesCount: number,
+    failedArchivesCount: number,
+  }
+}
+
+export class InputsDataSource extends jspb.Message {
+  getInputsAddJobId(): string;
+  setInputsAddJobId(value: string): InputsDataSource;
+
+  getUrl(): DataSourceURL | undefined;
+  setUrl(value?: DataSourceURL): InputsDataSource;
+  hasUrl(): boolean;
+  clearUrl(): InputsDataSource;
+
+  getInputIdConflictResolution(): InputIDConflictResolution;
+  setInputIdConflictResolution(value: InputIDConflictResolution): InputsDataSource;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): InputsDataSource.AsObject;
+  static toObject(includeInstance: boolean, msg: InputsDataSource): InputsDataSource.AsObject;
+  static serializeBinaryToWriter(message: InputsDataSource, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): InputsDataSource;
+  static deserializeBinaryFromReader(message: InputsDataSource, reader: jspb.BinaryReader): InputsDataSource;
+}
+
+export namespace InputsDataSource {
+  export type AsObject = {
+    inputsAddJobId: string,
+    url?: DataSourceURL.AsObject,
+    inputIdConflictResolution: InputIDConflictResolution,
+  }
+}
+
+export class DataSourceURL extends jspb.Message {
+  getUrl(): string;
+  setUrl(value: string): DataSourceURL;
+
+  getCredentials(): DataSourceCredentials | undefined;
+  setCredentials(value?: DataSourceCredentials): DataSourceURL;
+  hasCredentials(): boolean;
+  clearCredentials(): DataSourceURL;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DataSourceURL.AsObject;
+  static toObject(includeInstance: boolean, msg: DataSourceURL): DataSourceURL.AsObject;
+  static serializeBinaryToWriter(message: DataSourceURL, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DataSourceURL;
+  static deserializeBinaryFromReader(message: DataSourceURL, reader: jspb.BinaryReader): DataSourceURL;
+}
+
+export namespace DataSourceURL {
+  export type AsObject = {
+    url: string,
+    credentials?: DataSourceCredentials.AsObject,
+  }
+}
+
+export class DataSourceCredentials extends jspb.Message {
+  getS3Creds(): AWSCreds | undefined;
+  setS3Creds(value?: AWSCreds): DataSourceCredentials;
+  hasS3Creds(): boolean;
+  clearS3Creds(): DataSourceCredentials;
+
+  getGcpCreds(): Uint8Array | string;
+  getGcpCreds_asU8(): Uint8Array;
+  getGcpCreds_asB64(): string;
+  setGcpCreds(value: Uint8Array | string): DataSourceCredentials;
+
+  getAzureBlobCreds(): AzureBlobCreds | undefined;
+  setAzureBlobCreds(value?: AzureBlobCreds): DataSourceCredentials;
+  hasAzureBlobCreds(): boolean;
+  clearAzureBlobCreds(): DataSourceCredentials;
+
+  getCredentialsCase(): DataSourceCredentials.CredentialsCase;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DataSourceCredentials.AsObject;
+  static toObject(includeInstance: boolean, msg: DataSourceCredentials): DataSourceCredentials.AsObject;
+  static serializeBinaryToWriter(message: DataSourceCredentials, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DataSourceCredentials;
+  static deserializeBinaryFromReader(message: DataSourceCredentials, reader: jspb.BinaryReader): DataSourceCredentials;
+}
+
+export namespace DataSourceCredentials {
+  export type AsObject = {
+    s3Creds?: AWSCreds.AsObject,
+    gcpCreds: Uint8Array | string,
+    azureBlobCreds?: AzureBlobCreds.AsObject,
+  }
+
+  export enum CredentialsCase { 
+    CREDENTIALS_NOT_SET = 0,
+    S3_CREDS = 1,
+    GCP_CREDS = 2,
+    AZURE_BLOB_CREDS = 4,
+  }
+}
+
+export class AWSCreds extends jspb.Message {
+  getRegion(): string;
+  setRegion(value: string): AWSCreds;
+
+  getId(): string;
+  setId(value: string): AWSCreds;
+
+  getSecret(): string;
+  setSecret(value: string): AWSCreds;
+
+  getToken(): string;
+  setToken(value: string): AWSCreds;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AWSCreds.AsObject;
+  static toObject(includeInstance: boolean, msg: AWSCreds): AWSCreds.AsObject;
+  static serializeBinaryToWriter(message: AWSCreds, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AWSCreds;
+  static deserializeBinaryFromReader(message: AWSCreds, reader: jspb.BinaryReader): AWSCreds;
+}
+
+export namespace AWSCreds {
+  export type AsObject = {
+    region: string,
+    id: string,
+    secret: string,
+    token: string,
+  }
+}
+
+export class AzureBlobCreds extends jspb.Message {
+  getAccountName(): string;
+  setAccountName(value: string): AzureBlobCreds;
+
+  getAccountKey(): string;
+  setAccountKey(value: string): AzureBlobCreds;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AzureBlobCreds.AsObject;
+  static toObject(includeInstance: boolean, msg: AzureBlobCreds): AzureBlobCreds.AsObject;
+  static serializeBinaryToWriter(message: AzureBlobCreds, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AzureBlobCreds;
+  static deserializeBinaryFromReader(message: AzureBlobCreds, reader: jspb.BinaryReader): AzureBlobCreds;
+}
+
+export namespace AzureBlobCreds {
+  export type AsObject = {
+    accountName: string,
+    accountKey: string,
+  }
+}
+
+export class InputsUpload extends jspb.Message {
+  getInputsAddJobId(): string;
+  setInputsAddJobId(value: string): InputsUpload;
+
+  getAppPat(): string;
+  setAppPat(value: string): InputsUpload;
+
+  getUpload(): Upload | undefined;
+  setUpload(value?: Upload): InputsUpload;
+  hasUpload(): boolean;
+  clearUpload(): InputsUpload;
+
+  getInputIdConflictResolution(): InputIDConflictResolution;
+  setInputIdConflictResolution(value: InputIDConflictResolution): InputsUpload;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): InputsUpload.AsObject;
+  static toObject(includeInstance: boolean, msg: InputsUpload): InputsUpload.AsObject;
+  static serializeBinaryToWriter(message: InputsUpload, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): InputsUpload;
+  static deserializeBinaryFromReader(message: InputsUpload, reader: jspb.BinaryReader): InputsUpload;
+}
+
+export namespace InputsUpload {
+  export type AsObject = {
+    inputsAddJobId: string,
+    appPat: string,
+    upload?: Upload.AsObject,
+    inputIdConflictResolution: InputIDConflictResolution,
+  }
+}
+
 export enum DatasetVersionMetricsGroupType { 
   DATASET_VERSION_METRICS_GROUP_TYPE_NOT_SET = 0,
   INPUT_TYPE = 2,
@@ -6641,8 +7469,12 @@ export enum ValueComparator {
   EQUAL = 5,
 }
 export enum EvaluationType { 
-  CLASSIFICATION = 0,
-  DETECTION = 1,
+  UNDEFINED = 0,
+  CLASSIFICATION = 1,
+  DETECTION = 2,
+  SEGMENTATION = 3,
+  CLUSTERING = 4,
+  TRACKER = 5,
 }
 export enum APIEventType { 
   API_EVENT_TYPE_NOT_SET = 0,
@@ -6656,6 +7488,15 @@ export enum UsageIntervalType {
   MONTH = 2,
   YEAR = 3,
 }
+export enum AnnotationDataType { 
+  ANNOTATION_DATA_TYPE_NOT_SET = 0,
+  TAG = 1,
+  BOUNDING_BOX = 2,
+  POLYGON = 4,
+  POINT = 8,
+  SPAN = 16,
+  MASK = 32,
+}
 export enum RoleType { 
   TEAM = 0,
   ORG = 1,
@@ -6679,3 +7520,8 @@ export enum ValidationErrorType {
   DATABASE = 2,
   FORMAT = 3,
 }
+export enum InputIDConflictResolution { 
+  INPUT_ID_CONFLICT_RESOLUTION_NOT_SET = 0,
+  SKIP = 1,
+  SUFFIX = 2,
+}