clarifai-web-grpc 5.1.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;
 
@@ -167,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,
@@ -1590,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;
@@ -1682,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;
@@ -1703,6 +1736,8 @@ export namespace Dataset {
     defaultAnnotationFilter?: AnnotationFilter.AsObject,
     notes: string,
     version?: DatasetVersion.AsObject,
+    isStarred: boolean,
+    starCount: number,
   }
 }
 
@@ -1817,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;
 
@@ -1862,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,
@@ -1882,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;
@@ -1893,6 +1937,7 @@ export class AnnotationFilterConfig extends jspb.Message {
 export namespace AnnotationFilterConfig {
   export type AsObject = {
     annotationFilter?: AnnotationFilter.AsObject,
+    ignoreEmptyInputs: boolean,
   }
 }
 
@@ -2119,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;
@@ -2133,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,
   }
 }
 
@@ -2592,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;
 
@@ -2648,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,
@@ -2772,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;
@@ -3056,11 +3161,6 @@ 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;
@@ -3081,6 +3181,9 @@ export class ModelVersion extends jspb.Message {
   hasImportInfo(): boolean;
   clearImportInfo(): ModelVersion;
 
+  getTrainLog(): string;
+  setTrainLog(value: string): ModelVersion;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): ModelVersion.AsObject;
   static toObject(includeInstance: boolean, msg: ModelVersion): ModelVersion.AsObject;
@@ -3106,11 +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,
   }
 }
 
@@ -3523,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;
@@ -3559,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>,
@@ -3672,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;
@@ -3736,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,
@@ -3926,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;
@@ -4045,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;
@@ -4067,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,
   }
 }
 
@@ -4829,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;
@@ -4843,6 +4991,7 @@ export namespace WorkflowNode {
     model?: Model.AsObject,
     nodeInputsList: Array<NodeInput.AsObject>,
     suppressOutput: boolean,
+    outputInfoOverride?: OutputInfo.AsObject,
   }
 }
 
@@ -5191,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;
@@ -5219,6 +5376,8 @@ export namespace Task {
     appId: string,
     userId: string,
     labelOrderId: string,
+    conceptsList: Array<TaskConcept.AsObject>,
+    deletePreviousAnnotations: boolean,
   }
 
   export enum TaskType { 
@@ -5271,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;
@@ -5291,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,
   }
 
@@ -5518,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;
@@ -5802,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;
@@ -5935,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;
@@ -5973,6 +6310,12 @@ export class Module extends jspb.Message {
   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;
@@ -5992,6 +6335,8 @@ export namespace Module {
     userId: string,
     appId: string,
     moduleVersion?: ModuleVersion.AsObject,
+    isStarred: boolean,
+    starCount: number,
   }
 }
 
@@ -6195,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;
@@ -6241,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,
@@ -6254,6 +6605,7 @@ export namespace BulkOperation {
     INPUT_SOURCE_NOT_SET = 0,
     INPUT_IDS = 2,
     SEARCH = 10,
+    DATASET = 11,
   }
 }
 
@@ -6330,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;
@@ -6348,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 { 
@@ -6358,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,
   }
 }
 
@@ -6481,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;
 
@@ -6514,6 +6980,16 @@ export class InputsAddJob extends jspb.Message {
   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;
@@ -6525,13 +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,
   }
 }
 
@@ -6647,6 +7124,32 @@ 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;
@@ -6674,6 +7177,9 @@ export class InputsExtractionJob extends jspb.Message {
   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;
@@ -6690,13 +7196,11 @@ export namespace InputsExtractionJob {
     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 {
-  getReadObjectsCount(): number;
-  setReadObjectsCount(value: number): InputsExtractionJobProgress;
-
   getAudioInputsCount(): number;
   setAudioInputsCount(value: number): InputsExtractionJobProgress;
 
@@ -6709,6 +7213,18 @@ export class InputsExtractionJobProgress extends jspb.Message {
   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;
@@ -6719,11 +7235,14 @@ export class InputsExtractionJobProgress extends jspb.Message {
 
 export namespace InputsExtractionJobProgress {
   export type AsObject = {
-    readObjectsCount: number,
     audioInputsCount: number,
     imageInputsCount: number,
     videoInputsCount: number,
     textInputsCount: number,
+    pendingArchivesCount: number,
+    inProgressArchivesCount: number,
+    completedArchivesCount: number,
+    failedArchivesCount: number,
   }
 }
 
@@ -6736,6 +7255,9 @@ export class InputsDataSource extends jspb.Message {
   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;
@@ -6748,6 +7270,7 @@ export namespace InputsDataSource {
   export type AsObject = {
     inputsAddJobId: string,
     url?: DataSourceURL.AsObject,
+    inputIdConflictResolution: InputIDConflictResolution,
   }
 }
 
@@ -6786,8 +7309,10 @@ export class DataSourceCredentials extends jspb.Message {
   getGcpCreds_asB64(): string;
   setGcpCreds(value: Uint8Array | string): DataSourceCredentials;
 
-  getAzureBlobCreds(): string;
-  setAzureBlobCreds(value: string): DataSourceCredentials;
+  getAzureBlobCreds(): AzureBlobCreds | undefined;
+  setAzureBlobCreds(value?: AzureBlobCreds): DataSourceCredentials;
+  hasAzureBlobCreds(): boolean;
+  clearAzureBlobCreds(): DataSourceCredentials;
 
   getCredentialsCase(): DataSourceCredentials.CredentialsCase;
 
@@ -6803,24 +7328,30 @@ export namespace DataSourceCredentials {
   export type AsObject = {
     s3Creds?: AWSCreds.AsObject,
     gcpCreds: Uint8Array | string,
-    azureBlobCreds: string,
+    azureBlobCreds?: AzureBlobCreds.AsObject,
   }
 
   export enum CredentialsCase { 
     CREDENTIALS_NOT_SET = 0,
     S3_CREDS = 1,
     GCP_CREDS = 2,
-    AZURE_BLOB_CREDS = 3,
+    AZURE_BLOB_CREDS = 4,
   }
 }
 
 export class AWSCreds extends jspb.Message {
-  getCreds(): string;
-  setCreds(value: string): AWSCreds;
-
   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;
@@ -6831,8 +7362,64 @@ export class AWSCreds extends jspb.Message {
 
 export namespace AWSCreds {
   export type AsObject = {
-    creds: string,
     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,
   }
 }
 
@@ -6901,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,
@@ -6924,3 +7520,8 @@ export enum ValidationErrorType {
   DATABASE = 2,
   FORMAT = 3,
 }
+export enum InputIDConflictResolution { 
+  INPUT_ID_CONFLICT_RESOLUTION_NOT_SET = 0,
+  SKIP = 1,
+  SUFFIX = 2,
+}