// package: clarifai.api
// file: proto/clarifai/api/resources.proto

/* tslint:disable */
/* eslint-disable */

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_api_utils_time_pb from "../../../proto/clarifai/api/utils/time_pb";
import * as proto_clarifai_auth_util_extension_pb from "../../../proto/clarifai/auth/util/extension_pb";
import * as google_protobuf_duration_pb from "google-protobuf/google/protobuf/duration_pb";
import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/struct_pb";
import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb";
import * as google_protobuf_wrappers_pb from "google-protobuf/google/protobuf/wrappers_pb";

export class Annotation extends jspb.Message { 
    getId(): string;
    setId(value: string): Annotation;
    getInputId(): string;
    setInputId(value: string): Annotation;

    hasData(): boolean;
    clearData(): void;
    getData(): Data | undefined;
    setData(value?: Data): Annotation;

    hasAnnotationInfo(): boolean;
    clearAnnotationInfo(): void;
    getAnnotationInfo(): google_protobuf_struct_pb.Struct | undefined;
    setAnnotationInfo(value?: google_protobuf_struct_pb.Struct): Annotation;
    getUserId(): string;
    setUserId(value: string): Annotation;
    getModelVersionId(): string;
    setModelVersionId(value: string): Annotation;
    getEmbedModelVersionId(): string;
    setEmbedModelVersionId(value: string): Annotation;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): Annotation;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Annotation;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Annotation;
    getTrusted(): boolean;
    setTrusted(value: boolean): Annotation;
    getInputLevel(): boolean;
    setInputLevel(value: boolean): Annotation;

    hasConsensusInfo(): boolean;
    clearConsensusInfo(): void;
    getConsensusInfo(): google_protobuf_struct_pb.Struct | undefined;
    setConsensusInfo(value?: google_protobuf_struct_pb.Struct): Annotation;
    getTaskId(): string;
    setTaskId(value: string): Annotation;

    hasWorker(): boolean;
    clearWorker(): void;
    getWorker(): Worker | undefined;
    setWorker(value?: Worker): Annotation;

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

export namespace Annotation {
    export type AsObject = {
        id: string,
        inputId: string,
        data?: Data.AsObject,
        annotationInfo?: google_protobuf_struct_pb.Struct.AsObject,
        userId: string,
        modelVersionId: string,
        embedModelVersionId: string,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        trusted: boolean,
        inputLevel: boolean,
        consensusInfo?: google_protobuf_struct_pb.Struct.AsObject,
        taskId: string,
        worker?: Worker.AsObject,
    }
}

export class AnnotationTrack extends jspb.Message { 
    getId(): string;
    setId(value: string): AnnotationTrack;
    getInputId(): string;
    setInputId(value: string): AnnotationTrack;

    hasConcept(): boolean;
    clearConcept(): void;
    getConcept(): Concept | undefined;
    setConcept(value?: Concept): AnnotationTrack;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): AnnotationTrack;
    getStartFrameNr(): number;
    setStartFrameNr(value: number): AnnotationTrack;
    getEndFrameNr(): number;
    setEndFrameNr(value: number): AnnotationTrack;
    getStartFrameMs(): number;
    setStartFrameMs(value: number): AnnotationTrack;
    getEndFrameMs(): number;
    setEndFrameMs(value: number): AnnotationTrack;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): AnnotationTrack;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): AnnotationTrack;
    getSampleRateMs(): number;
    setSampleRateMs(value: number): AnnotationTrack;
    getSampleRateFrame(): number;
    setSampleRateFrame(value: number): AnnotationTrack;

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

export namespace AnnotationTrack {
    export type AsObject = {
        id: string,
        inputId: string,
        concept?: Concept.AsObject,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        startFrameNr: number,
        endFrameNr: number,
        startFrameMs: number,
        endFrameMs: number,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        sampleRateMs: number,
        sampleRateFrame: number,
    }
}

export class Worker extends jspb.Message { 

    hasUser(): boolean;
    clearUser(): void;
    getUser(): User | undefined;
    setUser(value?: User): Worker;

    hasModel(): boolean;
    clearModel(): void;
    getModel(): Model | undefined;
    setModel(value?: Model): Worker;

    hasWorkflow(): boolean;
    clearWorkflow(): void;
    getWorkflow(): Workflow | undefined;
    setWorkflow(value?: Workflow): Worker;

    getWorkerCase(): Worker.WorkerCase;

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

export namespace Worker {
    export type AsObject = {
        user?: User.AsObject,
        model?: Model.AsObject,
        workflow?: Workflow.AsObject,
    }

    export enum WorkerCase {
        WORKER_NOT_SET = 0,
        USER = 1,
        MODEL = 2,
        WORKFLOW = 3,
    }

}

export class App extends jspb.Message { 
    getId(): string;
    setId(value: string): App;
    getName(): string;
    setName(value: string): App;
    getDefaultLanguage(): string;
    setDefaultLanguage(value: string): App;
    getDefaultWorkflowId(): string;
    setDefaultWorkflowId(value: string): App;

    hasDefaultWorkflow(): boolean;
    clearDefaultWorkflow(): void;
    getDefaultWorkflow(): Workflow | undefined;
    setDefaultWorkflow(value?: Workflow): App;
    getUserId(): string;
    setUserId(value: string): App;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): App;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): App;
    getLegalConsentStatus(): number;
    setLegalConsentStatus(value: number): App;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): App;
    getDescription(): string;
    setDescription(value: string): App;
    getSampleMs(): number;
    setSampleMs(value: number): App;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): App;
    getDataTierId(): string;
    setDataTierId(value: string): App;
    getIsStarred(): boolean;
    setIsStarred(value: boolean): App;
    getStarCount(): number;
    setStarCount(value: number): App;
    getNotes(): string;
    setNotes(value: string): App;

    hasImage(): boolean;
    clearImage(): void;
    getImage(): Image | undefined;
    setImage(value?: Image): App;

    hasIsTemplate(): boolean;
    clearIsTemplate(): void;
    getIsTemplate(): google_protobuf_wrappers_pb.BoolValue | undefined;
    setIsTemplate(value?: google_protobuf_wrappers_pb.BoolValue): App;

    hasExtraInfo(): boolean;
    clearExtraInfo(): void;
    getExtraInfo(): AppExtraInfo | undefined;
    setExtraInfo(value?: AppExtraInfo): App;
    getEmbeddingsStorage(): App.EmbeddingsStorage;
    setEmbeddingsStorage(value: App.EmbeddingsStorage): App;

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

export namespace App {
    export type AsObject = {
        id: string,
        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,
        legalConsentStatus: number,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        description: string,
        sampleMs: number,
        visibility?: Visibility.AsObject,
        dataTierId: string,
        isStarred: boolean,
        starCount: number,
        notes: string,
        image?: Image.AsObject,
        isTemplate?: google_protobuf_wrappers_pb.BoolValue.AsObject,
        extraInfo?: AppExtraInfo.AsObject,
        embeddingsStorage: App.EmbeddingsStorage,
    }

    export enum EmbeddingsStorage {
    EMBEDDING_STORAGE_NOT_SET = 0,
    POSTGRES = 1,
    QDRANT = 2,
    }

}

export class AppExtraInfo extends jspb.Message { 
    getSearchRevisionMarker(): string;
    setSearchRevisionMarker(value: string): AppExtraInfo;

    hasCounts(): boolean;
    clearCounts(): void;
    getCounts(): AppResourceCounts | undefined;
    setCounts(value?: AppResourceCounts): AppExtraInfo;

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

export namespace AppExtraInfo {
    export type AsObject = {
        searchRevisionMarker: string,
        counts?: AppResourceCounts.AsObject,
    }
}

export class AppQuery extends jspb.Message { 
    getName(): string;
    setName(value: string): AppQuery;

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

export namespace AppQuery {
    export type AsObject = {
        name: string,
    }
}

export class AppResourceCounts extends jspb.Message { 
    getDatasets(): number;
    setDatasets(value: number): AppResourceCounts;
    getModels(): number;
    setModels(value: number): AppResourceCounts;
    getWorkflows(): number;
    setWorkflows(value: number): AppResourceCounts;
    getInputs(): number;
    setInputs(value: number): AppResourceCounts;
    getPipelines(): number;
    setPipelines(value: number): AppResourceCounts;

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

export namespace AppResourceCounts {
    export type AsObject = {
        datasets: number,
        models: number,
        workflows: number,
        inputs: number,
        pipelines: number,
    }
}

export class Collaborator extends jspb.Message { 
    getId(): string;
    setId(value: string): Collaborator;

    hasApp(): boolean;
    clearApp(): void;
    getApp(): App | undefined;
    setApp(value?: App): Collaborator;

    hasUser(): boolean;
    clearUser(): void;
    getUser(): User | undefined;
    setUser(value?: User): Collaborator;
    clearScopesList(): void;
    getScopesList(): Array<string>;
    setScopesList(value: Array<string>): Collaborator;
    addScopes(value: string, index?: number): string;
    clearEndpointsList(): void;
    getEndpointsList(): Array<string>;
    setEndpointsList(value: Array<string>): Collaborator;
    addEndpoints(value: string, index?: number): string;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Collaborator;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Collaborator;

    hasDeletedAt(): boolean;
    clearDeletedAt(): void;
    getDeletedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDeletedAt(value?: google_protobuf_timestamp_pb.Timestamp): Collaborator;

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

export namespace Collaborator {
    export type AsObject = {
        id: string,
        app?: App.AsObject,
        user?: User.AsObject,
        scopesList: Array<string>,
        endpointsList: Array<string>,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        deletedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class Collaboration extends jspb.Message { 

    hasApp(): boolean;
    clearApp(): void;
    getApp(): App | undefined;
    setApp(value?: App): Collaboration;

    hasAppOwner(): boolean;
    clearAppOwner(): void;
    getAppOwner(): User | undefined;
    setAppOwner(value?: User): Collaboration;
    clearScopesList(): void;
    getScopesList(): Array<string>;
    setScopesList(value: Array<string>): Collaboration;
    addScopes(value: string, index?: number): string;
    clearEndpointsList(): void;
    getEndpointsList(): Array<string>;
    setEndpointsList(value: Array<string>): Collaboration;
    addEndpoints(value: string, index?: number): string;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Collaboration;

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

export namespace Collaboration {
    export type AsObject = {
        app?: App.AsObject,
        appOwner?: User.AsObject,
        scopesList: Array<string>,
        endpointsList: Array<string>,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class Audio extends jspb.Message { 
    getUrl(): string;
    setUrl(value: string): Audio;
    getBase64(): Uint8Array | string;
    getBase64_asU8(): Uint8Array;
    getBase64_asB64(): string;
    setBase64(value: Uint8Array | string): Audio;
    getAllowDuplicateUrl(): boolean;
    setAllowDuplicateUrl(value: boolean): Audio;

    hasHosted(): boolean;
    clearHosted(): void;
    getHosted(): HostedURL | undefined;
    setHosted(value?: HostedURL): Audio;

    hasAudioInfo(): boolean;
    clearAudioInfo(): void;
    getAudioInfo(): AudioInfo | undefined;
    setAudioInfo(value?: AudioInfo): Audio;

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

export namespace Audio {
    export type AsObject = {
        url: string,
        base64: Uint8Array | string,
        allowDuplicateUrl: boolean,
        hosted?: HostedURL.AsObject,
        audioInfo?: AudioInfo.AsObject,
    }
}

export class AudioInfo extends jspb.Message { 
    getAudioFormat(): string;
    setAudioFormat(value: string): AudioInfo;
    getSampleRate(): number;
    setSampleRate(value: number): AudioInfo;
    getDurationSeconds(): number;
    setDurationSeconds(value: number): AudioInfo;
    getBitRate(): number;
    setBitRate(value: number): AudioInfo;

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

export namespace AudioInfo {
    export type AsObject = {
        audioFormat: string,
        sampleRate: number,
        durationSeconds: number,
        bitRate: number,
    }
}

export class Track extends jspb.Message { 
    getId(): string;
    setId(value: string): Track;

    hasData(): boolean;
    clearData(): void;
    getData(): Data | undefined;
    setData(value?: Data): Track;

    hasTimeInfo(): boolean;
    clearTimeInfo(): void;
    getTimeInfo(): TimeInfo | undefined;
    setTimeInfo(value?: TimeInfo): Track;
    getQuality(): number;
    setQuality(value: number): Track;

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

export namespace Track {
    export type AsObject = {
        id: string,
        data?: Data.AsObject,
        timeInfo?: TimeInfo.AsObject,
        quality: number,
    }
}

export class Cluster extends jspb.Message { 
    getId(): string;
    setId(value: string): Cluster;
    getCount(): number;
    setCount(value: number): Cluster;
    getScore(): number;
    setScore(value: number): Cluster;
    clearHitsList(): void;
    getHitsList(): Array<Hit>;
    setHitsList(value: Array<Hit>): Cluster;
    addHits(value?: Hit, index?: number): Hit;
    clearProjectionList(): void;
    getProjectionList(): Array<number>;
    setProjectionList(value: Array<number>): Cluster;
    addProjection(value: number, index?: number): number;

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

export namespace Cluster {
    export type AsObject = {
        id: string,
        count: number,
        score: number,
        hitsList: Array<Hit.AsObject>,
        projectionList: Array<number>,
    }
}

export class Color extends jspb.Message { 
    getRawHex(): string;
    setRawHex(value: string): Color;

    hasW3c(): boolean;
    clearW3c(): void;
    getW3c(): W3C | undefined;
    setW3c(value?: W3C): Color;
    getValue(): number;
    setValue(value: number): Color;

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

export namespace Color {
    export type AsObject = {
        rawHex: string,
        w3c?: W3C.AsObject,
        value: number,
    }
}

export class W3C extends jspb.Message { 
    getHex(): string;
    setHex(value: string): W3C;
    getName(): string;
    setName(value: string): W3C;

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

export namespace W3C {
    export type AsObject = {
        hex: string,
        name: string,
    }
}

export class UserAppIDSet extends jspb.Message { 
    getUserId(): string;
    setUserId(value: string): UserAppIDSet;
    getAppId(): string;
    setAppId(value: string): UserAppIDSet;

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

export namespace UserAppIDSet {
    export type AsObject = {
        userId: string,
        appId: string,
    }
}

export class WorkerIDSet extends jspb.Message { 
    getUserId(): string;
    setUserId(value: string): WorkerIDSet;
    getAppId(): string;
    setAppId(value: string): WorkerIDSet;
    getModelId(): string;
    setModelId(value: string): WorkerIDSet;
    getModelVersionId(): string;
    setModelVersionId(value: string): WorkerIDSet;
    getWorkflowId(): string;
    setWorkflowId(value: string): WorkerIDSet;
    getWorkflowVersionId(): string;
    setWorkflowVersionId(value: string): WorkerIDSet;

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

export namespace WorkerIDSet {
    export type AsObject = {
        userId: string,
        appId: string,
        modelId: string,
        modelVersionId: string,
        workflowId: string,
        workflowVersionId: string,
    }
}

export class PatchAction extends jspb.Message { 
    getOp(): string;
    setOp(value: string): PatchAction;
    getMergeConflictResolution(): string;
    setMergeConflictResolution(value: string): PatchAction;
    getPath(): string;
    setPath(value: string): PatchAction;

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

export namespace PatchAction {
    export type AsObject = {
        op: string,
        mergeConflictResolution: string,
        path: string,
    }
}

export class Concept extends jspb.Message { 
    getId(): string;
    setId(value: string): Concept;
    getName(): string;
    setName(value: string): Concept;
    getValue(): number;
    setValue(value: number): Concept;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Concept;
    getLanguage(): string;
    setLanguage(value: string): Concept;
    getAppId(): string;
    setAppId(value: string): Concept;
    getDefinition(): string;
    setDefinition(value: string): Concept;
    getVocabId(): string;
    setVocabId(value: string): Concept;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): Concept;
    getUserId(): string;
    setUserId(value: string): Concept;

    hasKeypointInfo(): boolean;
    clearKeypointInfo(): void;
    getKeypointInfo(): KeypointInfo | undefined;
    setKeypointInfo(value?: KeypointInfo): Concept;

    hasExtraInfo(): boolean;
    clearExtraInfo(): void;
    getExtraInfo(): ConceptExtraInfo | undefined;
    setExtraInfo(value?: ConceptExtraInfo): Concept;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): Concept;

    hasImage(): boolean;
    clearImage(): void;
    getImage(): Image | undefined;
    setImage(value?: Image): Concept;

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

export namespace Concept {
    export type AsObject = {
        id: string,
        name: string,
        value: number,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        language: string,
        appId: string,
        definition: string,
        vocabId: string,
        visibility?: Visibility.AsObject,
        userId: string,
        keypointInfo?: KeypointInfo.AsObject,
        extraInfo?: ConceptExtraInfo.AsObject,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        image?: Image.AsObject,
    }
}

export class KeypointInfo extends jspb.Message { 
    clearKeypointNamesList(): void;
    getKeypointNamesList(): Array<string>;
    setKeypointNamesList(value: Array<string>): KeypointInfo;
    addKeypointNames(value: string, index?: number): string;
    clearSkeletonList(): void;
    getSkeletonList(): Array<KeypointEdge>;
    setSkeletonList(value: Array<KeypointEdge>): KeypointInfo;
    addSkeleton(value?: KeypointEdge, index?: number): KeypointEdge;

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

export namespace KeypointInfo {
    export type AsObject = {
        keypointNamesList: Array<string>,
        skeletonList: Array<KeypointEdge.AsObject>,
    }
}

export class KeypointEdge extends jspb.Message { 
    getK1(): number;
    setK1(value: number): KeypointEdge;
    getK2(): number;
    setK2(value: number): KeypointEdge;

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

export namespace KeypointEdge {
    export type AsObject = {
        k1: number,
        k2: number,
    }
}

export class ConceptExtraInfo extends jspb.Message { 
    getIsRankable(): boolean;
    setIsRankable(value: boolean): ConceptExtraInfo;

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

export namespace ConceptExtraInfo {
    export type AsObject = {
        isRankable: boolean,
    }
}

export class ConceptCount extends jspb.Message { 
    getId(): string;
    setId(value: string): ConceptCount;
    getName(): string;
    setName(value: string): ConceptCount;

    hasConceptTypeCount(): boolean;
    clearConceptTypeCount(): void;
    getConceptTypeCount(): ConceptTypeCount | undefined;
    setConceptTypeCount(value?: ConceptTypeCount): ConceptCount;

    hasDetailConceptCount(): boolean;
    clearDetailConceptCount(): void;
    getDetailConceptCount(): DetailConceptCount | undefined;
    setDetailConceptCount(value?: DetailConceptCount): ConceptCount;

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

export namespace ConceptCount {
    export type AsObject = {
        id: string,
        name: string,
        conceptTypeCount?: ConceptTypeCount.AsObject,
        detailConceptCount?: DetailConceptCount.AsObject,
    }
}

export class ConceptTypeCount extends jspb.Message { 
    getPositive(): number;
    setPositive(value: number): ConceptTypeCount;
    getNegative(): number;
    setNegative(value: number): ConceptTypeCount;

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

export namespace ConceptTypeCount {
    export type AsObject = {
        positive: number,
        negative: number,
    }
}

export class DetailConceptCount extends jspb.Message { 

    hasProcessed(): boolean;
    clearProcessed(): void;
    getProcessed(): ConceptTypeCount | undefined;
    setProcessed(value?: ConceptTypeCount): DetailConceptCount;

    hasToProcess(): boolean;
    clearToProcess(): void;
    getToProcess(): ConceptTypeCount | undefined;
    setToProcess(value?: ConceptTypeCount): DetailConceptCount;

    hasErrors(): boolean;
    clearErrors(): void;
    getErrors(): ConceptTypeCount | undefined;
    setErrors(value?: ConceptTypeCount): DetailConceptCount;

    hasProcessing(): boolean;
    clearProcessing(): void;
    getProcessing(): ConceptTypeCount | undefined;
    setProcessing(value?: ConceptTypeCount): DetailConceptCount;

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

export namespace DetailConceptCount {
    export type AsObject = {
        processed?: ConceptTypeCount.AsObject,
        toProcess?: ConceptTypeCount.AsObject,
        errors?: ConceptTypeCount.AsObject,
        processing?: ConceptTypeCount.AsObject,
    }
}

export class ConceptQuery extends jspb.Message { 
    getName(): string;
    setName(value: string): ConceptQuery;
    getLanguage(): string;
    setLanguage(value: string): ConceptQuery;
    getWorkflowId(): string;
    setWorkflowId(value: string): ConceptQuery;
    clearUseCasesList(): void;
    getUseCasesList(): Array<WorkflowModelUseCase>;
    setUseCasesList(value: Array<WorkflowModelUseCase>): ConceptQuery;
    addUseCases(value: WorkflowModelUseCase, index?: number): WorkflowModelUseCase;

    hasModel(): boolean;
    clearModel(): void;
    getModel(): Model | undefined;
    setModel(value?: Model): ConceptQuery;

    hasWorkflow(): boolean;
    clearWorkflow(): void;
    getWorkflow(): Workflow | undefined;
    setWorkflow(value?: Workflow): ConceptQuery;
    getIgnoreAppConcepts(): boolean;
    setIgnoreAppConcepts(value: boolean): ConceptQuery;

    getSourceCase(): ConceptQuery.SourceCase;

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

export namespace ConceptQuery {
    export type AsObject = {
        name: string,
        language: string,
        workflowId: string,
        useCasesList: Array<WorkflowModelUseCase>,
        model?: Model.AsObject,
        workflow?: Workflow.AsObject,
        ignoreAppConcepts: boolean,
    }

    export enum SourceCase {
        SOURCE_NOT_SET = 0,
        MODEL = 5,
        WORKFLOW = 6,
    }

}

export class ConceptRelation extends jspb.Message { 
    getId(): string;
    setId(value: string): ConceptRelation;

    hasSubjectConcept(): boolean;
    clearSubjectConcept(): void;
    getSubjectConcept(): Concept | undefined;
    setSubjectConcept(value?: Concept): ConceptRelation;

    hasObjectConcept(): boolean;
    clearObjectConcept(): void;
    getObjectConcept(): Concept | undefined;
    setObjectConcept(value?: Concept): ConceptRelation;
    getPredicate(): string;
    setPredicate(value: string): ConceptRelation;
    getKnowledgeGraphId(): string;
    setKnowledgeGraphId(value: string): ConceptRelation;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): ConceptRelation;

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

export namespace ConceptRelation {
    export type AsObject = {
        id: string,
        subjectConcept?: Concept.AsObject,
        objectConcept?: Concept.AsObject,
        predicate: string,
        knowledgeGraphId: string,
        visibility?: Visibility.AsObject,
    }
}

export class KnowledgeGraph extends jspb.Message { 
    getId(): string;
    setId(value: string): KnowledgeGraph;
    getName(): string;
    setName(value: string): KnowledgeGraph;
    getDescription(): string;
    setDescription(value: string): KnowledgeGraph;
    getExamplesAppId(): string;
    setExamplesAppId(value: string): KnowledgeGraph;
    getSampledExamplesAppId(): string;
    setSampledExamplesAppId(value: string): KnowledgeGraph;

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

export namespace KnowledgeGraph {
    export type AsObject = {
        id: string,
        name: string,
        description: string,
        examplesAppId: string,
        sampledExamplesAppId: string,
    }
}

export class ConceptLanguage extends jspb.Message { 
    getId(): string;
    setId(value: string): ConceptLanguage;
    getName(): string;
    setName(value: string): ConceptLanguage;
    getDefinition(): string;
    setDefinition(value: string): ConceptLanguage;

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

export namespace ConceptLanguage {
    export type AsObject = {
        id: string,
        name: string,
        definition: string,
    }
}

export class Data extends jspb.Message { 

    hasImage(): boolean;
    clearImage(): void;
    getImage(): Image | undefined;
    setImage(value?: Image): Data;

    hasVideo(): boolean;
    clearVideo(): void;
    getVideo(): Video | undefined;
    setVideo(value?: Video): Data;
    clearConceptsList(): void;
    getConceptsList(): Array<Concept>;
    setConceptsList(value: Array<Concept>): Data;
    addConcepts(value?: Concept, index?: number): Concept;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): Data;

    hasGeo(): boolean;
    clearGeo(): void;
    getGeo(): Geo | undefined;
    setGeo(value?: Geo): Data;
    clearColorsList(): void;
    getColorsList(): Array<Color>;
    setColorsList(value: Array<Color>): Data;
    addColors(value?: Color, index?: number): Color;
    clearClustersList(): void;
    getClustersList(): Array<Cluster>;
    setClustersList(value: Array<Cluster>): Data;
    addClusters(value?: Cluster, index?: number): Cluster;
    clearEmbeddingsList(): void;
    getEmbeddingsList(): Array<Embedding>;
    setEmbeddingsList(value: Array<Embedding>): Data;
    addEmbeddings(value?: Embedding, index?: number): Embedding;
    clearRegionsList(): void;
    getRegionsList(): Array<Region>;
    setRegionsList(value: Array<Region>): Data;
    addRegions(value?: Region, index?: number): Region;
    clearFramesList(): void;
    getFramesList(): Array<Frame>;
    setFramesList(value: Array<Frame>): Data;
    addFrames(value?: Frame, index?: number): Frame;

    hasText(): boolean;
    clearText(): void;
    getText(): Text | undefined;
    setText(value?: Text): Data;

    hasAudio(): boolean;
    clearAudio(): void;
    getAudio(): Audio | undefined;
    setAudio(value?: Audio): Data;
    clearTracksList(): void;
    getTracksList(): Array<Track>;
    setTracksList(value: Array<Track>): Data;
    addTracks(value?: Track, index?: number): Track;
    clearTimeSegmentsList(): void;
    getTimeSegmentsList(): Array<TimeSegment>;
    setTimeSegmentsList(value: Array<TimeSegment>): Data;
    addTimeSegments(value?: TimeSegment, index?: number): TimeSegment;
    clearHitsList(): void;
    getHitsList(): Array<Hit>;
    setHitsList(value: Array<Hit>): Data;
    addHits(value?: Hit, index?: number): Hit;
    clearHeatmapsList(): void;
    getHeatmapsList(): Array<Image>;
    setHeatmapsList(value: Array<Image>): Data;
    addHeatmaps(value?: Image, index?: number): Image;
    clearPartsList(): void;
    getPartsList(): Array<Part>;
    setPartsList(value: Array<Part>): Data;
    addParts(value?: Part, index?: number): Part;

    hasNdarray(): boolean;
    clearNdarray(): void;
    getNdarray(): NDArray | undefined;
    setNdarray(value?: NDArray): Data;
    getIntValue(): number;
    setIntValue(value: number): Data;
    getFloatValue(): number;
    setFloatValue(value: number): Data;
    getBytesValue(): Uint8Array | string;
    getBytesValue_asU8(): Uint8Array;
    getBytesValue_asB64(): string;
    setBytesValue(value: Uint8Array | string): Data;
    getBoolValue(): boolean;
    setBoolValue(value: boolean): Data;
    getStringValue(): string;
    setStringValue(value: string): Data;

    hasStructValue(): boolean;
    clearStructValue(): void;
    getStructValue(): google_protobuf_struct_pb.Struct | undefined;
    setStructValue(value?: google_protobuf_struct_pb.Struct): Data;

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

export namespace Data {
    export type AsObject = {
        image?: Image.AsObject,
        video?: Video.AsObject,
        conceptsList: Array<Concept.AsObject>,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        geo?: Geo.AsObject,
        colorsList: Array<Color.AsObject>,
        clustersList: Array<Cluster.AsObject>,
        embeddingsList: Array<Embedding.AsObject>,
        regionsList: Array<Region.AsObject>,
        framesList: Array<Frame.AsObject>,
        text?: Text.AsObject,
        audio?: Audio.AsObject,
        tracksList: Array<Track.AsObject>,
        timeSegmentsList: Array<TimeSegment.AsObject>,
        hitsList: Array<Hit.AsObject>,
        heatmapsList: Array<Image.AsObject>,
        partsList: Array<Part.AsObject>,
        ndarray?: NDArray.AsObject,
        intValue: number,
        floatValue: number,
        bytesValue: Uint8Array | string,
        boolValue: boolean,
        stringValue: string,
        structValue?: google_protobuf_struct_pb.Struct.AsObject,
    }
}

export class Part extends jspb.Message { 

    hasData(): boolean;
    clearData(): void;
    getData(): Data | undefined;
    setData(value?: Data): Part;
    getId(): string;
    setId(value: string): Part;

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

export namespace Part {
    export type AsObject = {
        data?: Data.AsObject,
        id: string,
    }
}

export class Region extends jspb.Message { 
    getId(): string;
    setId(value: string): Region;

    hasRegionInfo(): boolean;
    clearRegionInfo(): void;
    getRegionInfo(): RegionInfo | undefined;
    setRegionInfo(value?: RegionInfo): Region;

    hasData(): boolean;
    clearData(): void;
    getData(): Data | undefined;
    setData(value?: Data): Region;
    getValue(): number;
    setValue(value: number): Region;
    getTrackId(): string;
    setTrackId(value: string): Region;

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

export namespace Region {
    export type AsObject = {
        id: string,
        regionInfo?: RegionInfo.AsObject,
        data?: Data.AsObject,
        value: number,
        trackId: string,
    }
}

export class RegionInfo extends jspb.Message { 

    hasBoundingBox(): boolean;
    clearBoundingBox(): void;
    getBoundingBox(): BoundingBox | undefined;
    setBoundingBox(value?: BoundingBox): RegionInfo;

    hasMask(): boolean;
    clearMask(): void;
    getMask(): Mask | undefined;
    setMask(value?: Mask): RegionInfo;

    hasPolygon(): boolean;
    clearPolygon(): void;
    getPolygon(): Polygon | undefined;
    setPolygon(value?: Polygon): RegionInfo;

    hasPoint(): boolean;
    clearPoint(): void;
    getPoint(): Point | undefined;
    setPoint(value?: Point): RegionInfo;

    hasSpan(): boolean;
    clearSpan(): void;
    getSpan(): Span | undefined;
    setSpan(value?: Span): RegionInfo;

    hasToken(): boolean;
    clearToken(): void;
    getToken(): Token | undefined;
    setToken(value?: Token): RegionInfo;
    clearKeypointLocationsList(): void;
    getKeypointLocationsList(): Array<Point>;
    setKeypointLocationsList(value: Array<Point>): RegionInfo;
    addKeypointLocations(value?: Point, index?: number): Point;

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

export namespace RegionInfo {
    export type AsObject = {
        boundingBox?: BoundingBox.AsObject,
        mask?: Mask.AsObject,
        polygon?: Polygon.AsObject,
        point?: Point.AsObject,
        span?: Span.AsObject,
        token?: Token.AsObject,
        keypointLocationsList: Array<Point.AsObject>,
    }
}

export class BoundingBox extends jspb.Message { 
    getTopRow(): number;
    setTopRow(value: number): BoundingBox;
    getLeftCol(): number;
    setLeftCol(value: number): BoundingBox;
    getBottomRow(): number;
    setBottomRow(value: number): BoundingBox;
    getRightCol(): number;
    setRightCol(value: number): BoundingBox;

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

export namespace BoundingBox {
    export type AsObject = {
        topRow: number,
        leftCol: number,
        bottomRow: number,
        rightCol: number,
    }
}

export class FrameInfo extends jspb.Message { 
    getIndex(): number;
    setIndex(value: number): FrameInfo;
    getTime(): number;
    setTime(value: number): FrameInfo;
    getNumber(): number;
    setNumber(value: number): FrameInfo;

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

export namespace FrameInfo {
    export type AsObject = {
        index: number,
        time: number,
        number: number,
    }
}

export class Frame extends jspb.Message { 

    hasFrameInfo(): boolean;
    clearFrameInfo(): void;
    getFrameInfo(): FrameInfo | undefined;
    setFrameInfo(value?: FrameInfo): Frame;

    hasData(): boolean;
    clearData(): void;
    getData(): Data | undefined;
    setData(value?: Data): Frame;
    getId(): string;
    setId(value: string): Frame;

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

export namespace Frame {
    export type AsObject = {
        frameInfo?: FrameInfo.AsObject,
        data?: Data.AsObject,
        id: string,
    }
}

export class NDArray extends jspb.Message { 
    getBuffer(): Uint8Array | string;
    getBuffer_asU8(): Uint8Array;
    getBuffer_asB64(): string;
    setBuffer(value: Uint8Array | string): NDArray;
    clearShapeList(): void;
    getShapeList(): Array<number>;
    setShapeList(value: Array<number>): NDArray;
    addShape(value: number, index?: number): number;
    getDtype(): string;
    setDtype(value: string): NDArray;

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

export namespace NDArray {
    export type AsObject = {
        buffer: Uint8Array | string,
        shapeList: Array<number>,
        dtype: string,
    }
}

export class Mask extends jspb.Message { 

    hasImage(): boolean;
    clearImage(): void;
    getImage(): Image | undefined;
    setImage(value?: Image): Mask;

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

export namespace Mask {
    export type AsObject = {
        image?: Image.AsObject,
    }
}

export class Polygon extends jspb.Message { 
    clearPointsList(): void;
    getPointsList(): Array<Point>;
    setPointsList(value: Array<Point>): Polygon;
    addPoints(value?: Point, index?: number): Point;

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

export namespace Polygon {
    export type AsObject = {
        pointsList: Array<Point.AsObject>,
    }
}

export class Point extends jspb.Message { 
    getRow(): number;
    setRow(value: number): Point;
    getCol(): number;
    setCol(value: number): Point;
    getZ(): number;
    setZ(value: number): Point;
    getVisibility(): Point.Visibility;
    setVisibility(value: Point.Visibility): Point;

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

export namespace Point {
    export type AsObject = {
        row: number,
        col: number,
        z: number,
        visibility: Point.Visibility,
    }

    export enum Visibility {
    NOT_SET = 0,
    VISIBLE = 1,
    NOT_VISIBLE = 2,
    NOT_PRESENT = 3,
    }

}

export class Span extends jspb.Message { 
    getCharStart(): number;
    setCharStart(value: number): Span;
    getCharEnd(): number;
    setCharEnd(value: number): Span;
    getRawText(): string;
    setRawText(value: string): Span;

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

export namespace Span {
    export type AsObject = {
        charStart: number,
        charEnd: number,
        rawText: string,
    }
}

export class Token extends jspb.Message { 
    getCharStart(): number;
    setCharStart(value: number): Token;
    getCharEnd(): number;
    setCharEnd(value: number): Token;
    getRawText(): string;
    setRawText(value: string): Token;

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

export namespace Token {
    export type AsObject = {
        charStart: number,
        charEnd: number,
        rawText: string,
    }
}

export class Embedding extends jspb.Message { 
    clearVectorList(): void;
    getVectorList(): Array<number>;
    setVectorList(value: Array<number>): Embedding;
    addVector(value: number, index?: number): number;
    getNumDimensions(): number;
    setNumDimensions(value: number): Embedding;

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

export namespace Embedding {
    export type AsObject = {
        vectorList: Array<number>,
        numDimensions: number,
    }
}

export class GeoPoint extends jspb.Message { 
    getLongitude(): number;
    setLongitude(value: number): GeoPoint;
    getLatitude(): number;
    setLatitude(value: number): GeoPoint;

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

export namespace GeoPoint {
    export type AsObject = {
        longitude: number,
        latitude: number,
    }
}

export class GeoLimit extends jspb.Message { 
    getType(): string;
    setType(value: string): GeoLimit;
    getValue(): number;
    setValue(value: number): GeoLimit;

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

export namespace GeoLimit {
    export type AsObject = {
        type: string,
        value: number,
    }
}

export class GeoBoxedPoint extends jspb.Message { 

    hasGeoPoint(): boolean;
    clearGeoPoint(): void;
    getGeoPoint(): GeoPoint | undefined;
    setGeoPoint(value?: GeoPoint): GeoBoxedPoint;

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

export namespace GeoBoxedPoint {
    export type AsObject = {
        geoPoint?: GeoPoint.AsObject,
    }
}

export class Geo extends jspb.Message { 

    hasGeoPoint(): boolean;
    clearGeoPoint(): void;
    getGeoPoint(): GeoPoint | undefined;
    setGeoPoint(value?: GeoPoint): Geo;

    hasGeoLimit(): boolean;
    clearGeoLimit(): void;
    getGeoLimit(): GeoLimit | undefined;
    setGeoLimit(value?: GeoLimit): Geo;
    clearGeoBoxList(): void;
    getGeoBoxList(): Array<GeoBoxedPoint>;
    setGeoBoxList(value: Array<GeoBoxedPoint>): Geo;
    addGeoBox(value?: GeoBoxedPoint, index?: number): GeoBoxedPoint;

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

export namespace Geo {
    export type AsObject = {
        geoPoint?: GeoPoint.AsObject,
        geoLimit?: GeoLimit.AsObject,
        geoBoxList: Array<GeoBoxedPoint.AsObject>,
    }
}

export class Image extends jspb.Message { 
    getUrl(): string;
    setUrl(value: string): Image;
    getBase64(): Uint8Array | string;
    getBase64_asU8(): Uint8Array;
    getBase64_asB64(): string;
    setBase64(value: Uint8Array | string): Image;
    getAllowDuplicateUrl(): boolean;
    setAllowDuplicateUrl(value: boolean): Image;

    hasHosted(): boolean;
    clearHosted(): void;
    getHosted(): HostedURL | undefined;
    setHosted(value?: HostedURL): Image;

    hasImageInfo(): boolean;
    clearImageInfo(): void;
    getImageInfo(): ImageInfo | undefined;
    setImageInfo(value?: ImageInfo): Image;

    getHostedImageInfoMap(): jspb.Map<string, ImageInfo>;
    clearHostedImageInfoMap(): void;
    getDecodedBytes(): Uint8Array | string;
    getDecodedBytes_asU8(): Uint8Array;
    getDecodedBytes_asB64(): string;
    setDecodedBytes(value: Uint8Array | string): Image;

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

export namespace Image {
    export type AsObject = {
        url: string,
        base64: Uint8Array | string,
        allowDuplicateUrl: boolean,
        hosted?: HostedURL.AsObject,
        imageInfo?: ImageInfo.AsObject,

        hostedImageInfoMap: Array<[string, ImageInfo.AsObject]>,
        decodedBytes: Uint8Array | string,
    }
}

export class ImageInfo extends jspb.Message { 
    getWidth(): number;
    setWidth(value: number): ImageInfo;
    getHeight(): number;
    setHeight(value: number): ImageInfo;
    getFormat(): string;
    setFormat(value: string): ImageInfo;
    getColorMode(): string;
    setColorMode(value: string): ImageInfo;
    getMode(): string;
    setMode(value: string): ImageInfo;

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

export namespace ImageInfo {
    export type AsObject = {
        width: number,
        height: number,
        format: string,
        colorMode: string,
        mode: string,
    }
}

export class HostedURL extends jspb.Message { 
    getPrefix(): string;
    setPrefix(value: string): HostedURL;
    getSuffix(): string;
    setSuffix(value: string): HostedURL;
    clearSizesList(): void;
    getSizesList(): Array<string>;
    setSizesList(value: Array<string>): HostedURL;
    addSizes(value: string, index?: number): string;
    getCrossorigin(): string;
    setCrossorigin(value: string): HostedURL;

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

export namespace HostedURL {
    export type AsObject = {
        prefix: string,
        suffix: string,
        sizesList: Array<string>,
        crossorigin: string,
    }
}

export class Input extends jspb.Message { 
    getId(): string;
    setId(value: string): Input;

    hasData(): boolean;
    clearData(): void;
    getData(): Data | undefined;
    setData(value?: Data): Input;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Input;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Input;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): Input;
    clearDatasetIdsList(): void;
    getDatasetIdsList(): Array<string>;
    setDatasetIdsList(value: Array<string>): Input;
    addDatasetIds(value: string, index?: number): string;

    hasSettings(): boolean;
    clearSettings(): void;
    getSettings(): InputSettings | undefined;
    setSettings(value?: InputSettings): Input;

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

export namespace Input {
    export type AsObject = {
        id: string,
        data?: Data.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        datasetIdsList: Array<string>,
        settings?: InputSettings.AsObject,
    }
}

export class InputSettings extends jspb.Message { 

    hasWorker(): boolean;
    clearWorker(): void;
    getWorker(): Worker | undefined;
    setWorker(value?: Worker): InputSettings;
    getSampleRateMs(): number;
    setSampleRateMs(value: number): InputSettings;
    getSampleRateFrame(): number;
    setSampleRateFrame(value: number): InputSettings;
    clearPinnedConceptsList(): void;
    getPinnedConceptsList(): Array<Concept>;
    setPinnedConceptsList(value: Array<Concept>): InputSettings;
    addPinnedConcepts(value?: Concept, index?: number): Concept;

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

export namespace InputSettings {
    export type AsObject = {
        worker?: Worker.AsObject,
        sampleRateMs: number,
        sampleRateFrame: number,
        pinnedConceptsList: Array<Concept.AsObject>,
    }
}

export class InputBatch extends jspb.Message { 
    clearInputsList(): void;
    getInputsList(): Array<Input>;
    setInputsList(value: Array<Input>): InputBatch;
    addInputs(value?: Input, index?: number): Input;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): InputBatch.AsObject;
    static toObject(includeInstance: boolean, msg: InputBatch): InputBatch.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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;
    getToProcess(): number;
    setToProcess(value: number): InputCount;
    getErrors(): number;
    setErrors(value: number): InputCount;
    getProcessing(): number;
    setProcessing(value: number): InputCount;
    getReindexed(): number;
    setReindexed(value: number): InputCount;
    getToReindex(): number;
    setToReindex(value: number): InputCount;
    getReindexErrors(): number;
    setReindexErrors(value: number): InputCount;
    getReindexing(): number;
    setReindexing(value: number): InputCount;

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

export namespace InputCount {
    export type AsObject = {
        processed: number,
        toProcess: number,
        errors: number,
        processing: number,
        reindexed: number,
        toReindex: number,
        reindexErrors: number,
        reindexing: number,
    }
}

export class Dataset extends jspb.Message { 
    getId(): string;
    setId(value: string): Dataset;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Dataset;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Dataset;
    getAppId(): string;
    setAppId(value: string): Dataset;
    getUserId(): string;
    setUserId(value: string): Dataset;
    getDescription(): string;
    setDescription(value: string): Dataset;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): Dataset;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): Dataset;

    hasDefaultAnnotationFilter(): boolean;
    clearDefaultAnnotationFilter(): void;
    getDefaultAnnotationFilter(): AnnotationFilter | undefined;
    setDefaultAnnotationFilter(value?: AnnotationFilter): Dataset;

    hasDefaultProcessingInfo(): boolean;
    clearDefaultProcessingInfo(): void;
    getDefaultProcessingInfo(): DatasetVersionProcessingInfo | undefined;
    setDefaultProcessingInfo(value?: DatasetVersionProcessingInfo): Dataset;
    getNotes(): string;
    setNotes(value: string): Dataset;

    hasVersion(): boolean;
    clearVersion(): void;
    getVersion(): DatasetVersion | undefined;
    setVersion(value?: DatasetVersion): Dataset;
    getIsStarred(): boolean;
    setIsStarred(value: boolean): Dataset;
    getStarCount(): number;
    setStarCount(value: number): Dataset;

    hasBookmarkOrigin(): boolean;
    clearBookmarkOrigin(): void;
    getBookmarkOrigin(): BookmarkOrigin | undefined;
    setBookmarkOrigin(value?: BookmarkOrigin): Dataset;

    hasImage(): boolean;
    clearImage(): void;
    getImage(): Image | undefined;
    setImage(value?: Image): Dataset;

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

export namespace Dataset {
    export type AsObject = {
        id: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        appId: string,
        userId: string,
        description: string,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        visibility?: Visibility.AsObject,
        defaultAnnotationFilter?: AnnotationFilter.AsObject,
        defaultProcessingInfo?: DatasetVersionProcessingInfo.AsObject,
        notes: string,
        version?: DatasetVersion.AsObject,
        isStarred: boolean,
        starCount: number,
        bookmarkOrigin?: BookmarkOrigin.AsObject,
        image?: Image.AsObject,
    }
}

export class AnnotationFilter extends jspb.Message { 
    getId(): string;
    setId(value: string): AnnotationFilter;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): AnnotationFilter;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): AnnotationFilter;
    getUserId(): string;
    setUserId(value: string): AnnotationFilter;
    getAppId(): string;
    setAppId(value: string): AnnotationFilter;

    hasSearch(): boolean;
    clearSearch(): void;
    getSearch(): Search | undefined;
    setSearch(value?: Search): AnnotationFilter;

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

export namespace AnnotationFilter {
    export type AsObject = {
        id: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        userId: string,
        appId: string,
        search?: Search.AsObject,
    }
}

export class DatasetInput extends jspb.Message { 

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): DatasetInput;

    hasInput(): boolean;
    clearInput(): void;
    getInput(): Input | undefined;
    setInput(value?: Input): DatasetInput;

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

export namespace DatasetInput {
    export type AsObject = {
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        input?: Input.AsObject,
    }
}

export class DatasetVersion extends jspb.Message { 
    getId(): string;
    setId(value: string): DatasetVersion;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): DatasetVersion;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): DatasetVersion;
    getAppId(): string;
    setAppId(value: string): DatasetVersion;
    getUserId(): string;
    setUserId(value: string): DatasetVersion;
    getDatasetId(): string;
    setDatasetId(value: string): DatasetVersion;

    hasAnnotationFilterConfig(): boolean;
    clearAnnotationFilterConfig(): void;
    getAnnotationFilterConfig(): AnnotationFilterConfig | undefined;
    setAnnotationFilterConfig(value?: AnnotationFilterConfig): DatasetVersion;

    hasModelPredictConfig(): boolean;
    clearModelPredictConfig(): void;
    getModelPredictConfig(): ModelPredictConfig | undefined;
    setModelPredictConfig(value?: ModelPredictConfig): DatasetVersion;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): DatasetVersion;
    getDescription(): string;
    setDescription(value: string): DatasetVersion;

    hasProcessingInfo(): boolean;
    clearProcessingInfo(): void;
    getProcessingInfo(): DatasetVersionProcessingInfo | undefined;
    setProcessingInfo(value?: DatasetVersionProcessingInfo): DatasetVersion;

    getMetricsMap(): jspb.Map<string, DatasetVersionMetrics>;
    clearMetricsMap(): void;

    hasExportInfo(): boolean;
    clearExportInfo(): void;
    getExportInfo(): DatasetVersionExportInfo | undefined;
    setExportInfo(value?: DatasetVersionExportInfo): DatasetVersion;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): DatasetVersion;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): DatasetVersion;
    clearEmbedModelVersionIdsList(): void;
    getEmbedModelVersionIdsList(): Array<string>;
    setEmbedModelVersionIdsList(value: Array<string>): DatasetVersion;
    addEmbedModelVersionIds(value: string, index?: number): string;
    getRequestOrigin(): DatasetVersionRequestOrigin;
    setRequestOrigin(value: DatasetVersionRequestOrigin): DatasetVersion;

    getDataConfigCase(): DatasetVersion.DataConfigCase;

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

export namespace DatasetVersion {
    export type AsObject = {
        id: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        appId: string,
        userId: string,
        datasetId: string,
        annotationFilterConfig?: AnnotationFilterConfig.AsObject,
        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,
        visibility?: Visibility.AsObject,
        embedModelVersionIdsList: Array<string>,
        requestOrigin: DatasetVersionRequestOrigin,
    }

    export enum DataConfigCase {
        DATA_CONFIG_NOT_SET = 0,
        ANNOTATION_FILTER_CONFIG = 15,
        MODEL_PREDICT_CONFIG = 18,
    }

}

export class AnnotationFilterConfig extends jspb.Message { 

    hasAnnotationFilter(): boolean;
    clearAnnotationFilter(): void;
    getAnnotationFilter(): AnnotationFilter | undefined;
    setAnnotationFilter(value?: AnnotationFilter): AnnotationFilterConfig;
    getIgnoreEmptyInputs(): boolean;
    setIgnoreEmptyInputs(value: boolean): AnnotationFilterConfig;

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

export namespace AnnotationFilterConfig {
    export type AsObject = {
        annotationFilter?: AnnotationFilter.AsObject,
        ignoreEmptyInputs: boolean,
    }
}

export class ModelPredictConfig extends jspb.Message { 

    hasModel(): boolean;
    clearModel(): void;
    getModel(): Model | undefined;
    setModel(value?: Model): ModelPredictConfig;

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

export namespace ModelPredictConfig {
    export type AsObject = {
        model?: Model.AsObject,
    }
}

export class DatasetVersionMetrics extends jspb.Message { 

    hasInputsCount(): boolean;
    clearInputsCount(): void;
    getInputsCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setInputsCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasUnlabeledInputsCount(): boolean;
    clearUnlabeledInputsCount(): void;
    getUnlabeledInputsCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setUnlabeledInputsCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasInputsWithMetadataCount(): boolean;
    clearInputsWithMetadataCount(): void;
    getInputsWithMetadataCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setInputsWithMetadataCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasInputsWithGeoCount(): boolean;
    clearInputsWithGeoCount(): void;
    getInputsWithGeoCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setInputsWithGeoCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasRegionsCount(): boolean;
    clearRegionsCount(): void;
    getRegionsCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setRegionsCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasRegionLocationMatrix(): boolean;
    clearRegionLocationMatrix(): void;
    getRegionLocationMatrix(): proto_clarifai_api_utils_matrix_pb.MatrixUint64 | undefined;
    setRegionLocationMatrix(value?: proto_clarifai_api_utils_matrix_pb.MatrixUint64): DatasetVersionMetrics;

    hasBoundingBoxesCount(): boolean;
    clearBoundingBoxesCount(): void;
    getBoundingBoxesCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setBoundingBoxesCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasPolygonsCount(): boolean;
    clearPolygonsCount(): void;
    getPolygonsCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setPolygonsCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasPointsCount(): boolean;
    clearPointsCount(): void;
    getPointsCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setPointsCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasMasksCount(): boolean;
    clearMasksCount(): void;
    getMasksCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setMasksCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasRegionInputsCount(): boolean;
    clearRegionInputsCount(): void;
    getRegionInputsCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setRegionInputsCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasRegionFramesCount(): boolean;
    clearRegionFramesCount(): void;
    getRegionFramesCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setRegionFramesCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasFramesCount(): boolean;
    clearFramesCount(): void;
    getFramesCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setFramesCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasFrameInputsCount(): boolean;
    clearFrameInputsCount(): void;
    getFrameInputsCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setFrameInputsCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasEmbeddingsCount(): boolean;
    clearEmbeddingsCount(): void;
    getEmbeddingsCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setEmbeddingsCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasPositiveInputTagsCount(): boolean;
    clearPositiveInputTagsCount(): void;
    getPositiveInputTagsCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setPositiveInputTagsCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasPositiveRegionTagsCount(): boolean;
    clearPositiveRegionTagsCount(): void;
    getPositiveRegionTagsCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setPositiveRegionTagsCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

    hasPositiveFrameTagsCount(): boolean;
    clearPositiveFrameTagsCount(): void;
    getPositiveFrameTagsCount(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setPositiveFrameTagsCount(value?: google_protobuf_wrappers_pb.UInt64Value): DatasetVersionMetrics;

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

export namespace DatasetVersionMetrics {
    export type AsObject = {
        inputsCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        unlabeledInputsCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        inputsWithMetadataCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        inputsWithGeoCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        regionsCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        regionLocationMatrix?: proto_clarifai_api_utils_matrix_pb.MatrixUint64.AsObject,
        boundingBoxesCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        polygonsCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        pointsCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        masksCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        regionInputsCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        regionFramesCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        framesCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        frameInputsCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        embeddingsCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        positiveInputTagsCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        positiveRegionTagsCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        positiveFrameTagsCount?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
    }
}

export class DatasetVersionMetricsGroup extends jspb.Message { 
    getParentPath(): string;
    setParentPath(value: string): DatasetVersionMetricsGroup;
    getType(): DatasetVersionMetricsGroupType;
    setType(value: DatasetVersionMetricsGroupType): DatasetVersionMetricsGroup;

    hasValue(): boolean;
    clearValue(): void;
    getValue(): google_protobuf_struct_pb.Value | undefined;
    setValue(value?: google_protobuf_struct_pb.Value): DatasetVersionMetricsGroup;

    hasMetrics(): boolean;
    clearMetrics(): void;
    getMetrics(): DatasetVersionMetrics | undefined;
    setMetrics(value?: DatasetVersionMetrics): DatasetVersionMetricsGroup;

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

export namespace DatasetVersionMetricsGroup {
    export type AsObject = {
        parentPath: string,
        type: DatasetVersionMetricsGroupType,
        value?: google_protobuf_struct_pb.Value.AsObject,
        metrics?: DatasetVersionMetrics.AsObject,
    }
}

export class DatasetVersionExportInfo extends jspb.Message { 

    hasClarifaiDataProtobuf(): boolean;
    clearClarifaiDataProtobuf(): void;
    getClarifaiDataProtobuf(): DatasetVersionExport | undefined;
    setClarifaiDataProtobuf(value?: DatasetVersionExport): DatasetVersionExportInfo;

    hasClarifaiDataJson(): boolean;
    clearClarifaiDataJson(): void;
    getClarifaiDataJson(): DatasetVersionExport | undefined;
    setClarifaiDataJson(value?: DatasetVersionExport): DatasetVersionExportInfo;

    hasCoco(): boolean;
    clearCoco(): void;
    getCoco(): DatasetVersionExport | undefined;
    setCoco(value?: DatasetVersionExport): DatasetVersionExportInfo;

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

export namespace DatasetVersionExportInfo {
    export type AsObject = {
        clarifaiDataProtobuf?: DatasetVersionExport.AsObject,
        clarifaiDataJson?: DatasetVersionExport.AsObject,
        coco?: DatasetVersionExport.AsObject,
    }
}

export class DatasetVersionExport extends jspb.Message { 
    getFormat(): DatasetVersionExportFormat;
    setFormat(value: DatasetVersionExportFormat): DatasetVersionExport;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): DatasetVersionExport;
    getUrl(): string;
    setUrl(value: string): DatasetVersionExport;
    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;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: DatasetVersionExport, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): DatasetVersionExport;
    static deserializeBinaryFromReader(message: DatasetVersionExport, reader: jspb.BinaryReader): DatasetVersionExport;
}

export namespace DatasetVersionExport {
    export type AsObject = {
        format: DatasetVersionExportFormat,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        url: string,
        size: number,
        includeEmbeddings: boolean,
    }
}

export class DatasetVersionProcessingInfo extends jspb.Message { 

    hasFrameInterpolationInfo(): boolean;
    clearFrameInterpolationInfo(): void;
    getFrameInterpolationInfo(): FrameInterpolationInfo | undefined;
    setFrameInterpolationInfo(value?: FrameInterpolationInfo): DatasetVersionProcessingInfo;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): DatasetVersionProcessingInfo.AsObject;
    static toObject(includeInstance: boolean, msg: DatasetVersionProcessingInfo): DatasetVersionProcessingInfo.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
    }
}

export class Key extends jspb.Message { 
    getId(): string;
    setId(value: string): Key;
    getType(): string;
    setType(value: string): Key;
    getDescription(): string;
    setDescription(value: string): Key;
    clearScopesList(): void;
    getScopesList(): Array<string>;
    setScopesList(value: Array<string>): Key;
    addScopes(value: string, index?: number): string;
    clearEndpointsList(): void;
    getEndpointsList(): Array<string>;
    setEndpointsList(value: Array<string>): Key;
    addEndpoints(value: string, index?: number): string;
    clearAppsList(): void;
    getAppsList(): Array<App>;
    setAppsList(value: Array<App>): Key;
    addApps(value?: App, index?: number): App;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Key;

    hasExpiresAt(): boolean;
    clearExpiresAt(): void;
    getExpiresAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setExpiresAt(value?: google_protobuf_timestamp_pb.Timestamp): Key;
    clearAuthorizedIdpIdsList(): void;
    getAuthorizedIdpIdsList(): Array<string>;
    setAuthorizedIdpIdsList(value: Array<string>): Key;
    addAuthorizedIdpIds(value: string, index?: number): string;
    getOrganizationId(): string;
    setOrganizationId(value: string): Key;

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

export namespace Key {
    export type AsObject = {
        id: string,
        type: string,
        description: string,
        scopesList: Array<string>,
        endpointsList: Array<string>,
        appsList: Array<App.AsObject>,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        expiresAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        authorizedIdpIdsList: Array<string>,
        organizationId: string,
    }
}

export class Model extends jspb.Message { 
    getId(): string;
    setId(value: string): Model;
    getName(): string;
    setName(value: string): Model;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Model;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Model;
    getAppId(): string;
    setAppId(value: string): Model;

    hasOutputInfo(): boolean;
    clearOutputInfo(): void;
    getOutputInfo(): OutputInfo | undefined;
    setOutputInfo(value?: OutputInfo): Model;

    hasModelVersion(): boolean;
    clearModelVersion(): void;
    getModelVersion(): ModelVersion | undefined;
    setModelVersion(value?: ModelVersion): Model;
    getDisplayName(): string;
    setDisplayName(value: string): Model;
    getUserId(): string;
    setUserId(value: string): Model;

    hasDefaultEvalInfo(): boolean;
    clearDefaultEvalInfo(): void;
    getDefaultEvalInfo(): EvalInfo | undefined;
    setDefaultEvalInfo(value?: EvalInfo): Model;
    getModelTypeId(): string;
    setModelTypeId(value: string): Model;
    getTask(): string;
    setTask(value: string): Model;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): Model;
    getDescription(): string;
    setDescription(value: string): Model;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): Model;

    hasPresets(): boolean;
    clearPresets(): void;
    getPresets(): google_protobuf_struct_pb.Struct | undefined;
    setPresets(value?: google_protobuf_struct_pb.Struct): Model;
    getNotes(): string;
    setNotes(value: string): Model;
    clearToolkitsList(): void;
    getToolkitsList(): Array<string>;
    setToolkitsList(value: Array<string>): Model;
    addToolkits(value: string, index?: number): string;
    clearUseCasesList(): void;
    getUseCasesList(): Array<string>;
    setUseCasesList(value: Array<string>): Model;
    addUseCases(value: string, index?: number): string;
    clearLanguagesList(): void;
    getLanguagesList(): Array<string>;
    setLanguagesList(value: Array<string>): Model;
    addLanguages(value: string, index?: number): string;
    clearLanguagesFullList(): void;
    getLanguagesFullList(): Array<FullTag>;
    setLanguagesFullList(value: Array<FullTag>): Model;
    addLanguagesFull(value?: FullTag, index?: number): FullTag;
    clearCheckConsentsList(): void;
    getCheckConsentsList(): Array<string>;
    setCheckConsentsList(value: Array<string>): Model;
    addCheckConsents(value: string, index?: number): string;
    getIsStarred(): boolean;
    setIsStarred(value: boolean): Model;
    getStarCount(): number;
    setStarCount(value: number): Model;

    hasWorkflowRecommended(): boolean;
    clearWorkflowRecommended(): void;
    getWorkflowRecommended(): google_protobuf_wrappers_pb.BoolValue | undefined;
    setWorkflowRecommended(value?: google_protobuf_wrappers_pb.BoolValue): Model;

    hasBookmarkOrigin(): boolean;
    clearBookmarkOrigin(): void;
    getBookmarkOrigin(): BookmarkOrigin | undefined;
    setBookmarkOrigin(value?: BookmarkOrigin): Model;

    hasImage(): boolean;
    clearImage(): void;
    getImage(): Image | undefined;
    setImage(value?: Image): Model;
    getLicenseType(): LicenseType;
    setLicenseType(value: LicenseType): Model;
    getSource(): Model.Source;
    setSource(value: Model.Source): Model;
    getCreator(): string;
    setCreator(value: string): Model;
    getVersionCount(): number;
    setVersionCount(value: number): Model;
    getBillingType(): Model.BillingType;
    setBillingType(value: Model.BillingType): Model;

    hasFeaturedOrder(): boolean;
    clearFeaturedOrder(): void;
    getFeaturedOrder(): google_protobuf_wrappers_pb.Int32Value | undefined;
    setFeaturedOrder(value?: google_protobuf_wrappers_pb.Int32Value): Model;
    getDeployRestriction(): DeployRestriction;
    setDeployRestriction(value: DeployRestriction): Model;
    getReplicaCount(): number;
    setReplicaCount(value: number): Model;

    hasOpenRouterInfo(): boolean;
    clearOpenRouterInfo(): void;
    getOpenRouterInfo(): OpenRouterInfo | undefined;
    setOpenRouterInfo(value?: OpenRouterInfo): Model;

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

export namespace Model {
    export type AsObject = {
        id: string,
        name: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        appId: string,
        outputInfo?: OutputInfo.AsObject,
        modelVersion?: ModelVersion.AsObject,
        displayName: string,
        userId: string,
        defaultEvalInfo?: EvalInfo.AsObject,
        modelTypeId: string,
        task: string,
        visibility?: Visibility.AsObject,
        description: string,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        presets?: google_protobuf_struct_pb.Struct.AsObject,
        notes: string,
        toolkitsList: Array<string>,
        useCasesList: Array<string>,
        languagesList: Array<string>,
        languagesFullList: Array<FullTag.AsObject>,
        checkConsentsList: Array<string>,
        isStarred: boolean,
        starCount: number,
        workflowRecommended?: google_protobuf_wrappers_pb.BoolValue.AsObject,
        bookmarkOrigin?: BookmarkOrigin.AsObject,
        image?: Image.AsObject,
        licenseType: LicenseType,
        source: Model.Source,
        creator: string,
        versionCount: number,
        billingType: Model.BillingType,
        featuredOrder?: google_protobuf_wrappers_pb.Int32Value.AsObject,
        deployRestriction: DeployRestriction,
        replicaCount: number,
        openRouterInfo?: OpenRouterInfo.AsObject,
    }

    export enum Source {
    UNKNOWN_SOURCE = 0,
    HOSTED = 1,
    WRAPPED = 2,
    }

    export enum BillingType {
    UNKNOWN = 0,
    TOKENS = 1,
    OPS = 2,
    }

}

export class SpecialHandling extends jspb.Message { 
    getId(): string;
    setId(value: string): SpecialHandling;
    getReason(): SpecialHandling.Reason;
    setReason(value: SpecialHandling.Reason): SpecialHandling;
    getDone(): boolean;
    setDone(value: boolean): SpecialHandling;

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

export namespace SpecialHandling {
    export type AsObject = {
        id: string,
        reason: SpecialHandling.Reason,
        done: boolean,
    }

    export enum Reason {
    REASON_NOT_SET = 0,
    CONTACT_SALES = 1,
    INTERNAL_ONLY = 2,
    }

}

export class OpenRouterInfo extends jspb.Message { 

    hasParams(): boolean;
    clearParams(): void;
    getParams(): google_protobuf_struct_pb.Struct | undefined;
    setParams(value?: google_protobuf_struct_pb.Struct): OpenRouterInfo;

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

export namespace OpenRouterInfo {
    export type AsObject = {
        params?: google_protobuf_struct_pb.Struct.AsObject,
    }
}

export class ModelReference extends jspb.Message { 
    getId(): string;
    setId(value: string): ModelReference;
    getModelId(): string;
    setModelId(value: string): ModelReference;
    getUrl(): string;
    setUrl(value: string): ModelReference;
    getName(): string;
    setName(value: string): ModelReference;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): ModelReference;

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

export namespace ModelReference {
    export type AsObject = {
        id: string,
        modelId: string,
        url: string,
        name: string,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
    }
}

export class ModelVersionInputExample extends jspb.Message { 
    getId(): string;
    setId(value: string): ModelVersionInputExample;
    getModelId(): string;
    setModelId(value: string): ModelVersionInputExample;
    getModelVersionId(): string;
    setModelVersionId(value: string): ModelVersionInputExample;

    hasData(): boolean;
    clearData(): void;
    getData(): Data | undefined;
    setData(value?: Data): ModelVersionInputExample;
    getName(): string;
    setName(value: string): ModelVersionInputExample;
    getDescription(): string;
    setDescription(value: string): ModelVersionInputExample;

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

export namespace ModelVersionInputExample {
    export type AsObject = {
        id: string,
        modelId: string,
        modelVersionId: string,
        data?: Data.AsObject,
        name: string,
        description: string,
    }
}

export class OutputInfo extends jspb.Message { 

    hasData(): boolean;
    clearData(): void;
    getData(): Data | undefined;
    setData(value?: Data): OutputInfo;

    hasOutputConfig(): boolean;
    clearOutputConfig(): void;
    getOutputConfig(): OutputConfig | undefined;
    setOutputConfig(value?: OutputConfig): OutputInfo;
    getMessage(): string;
    setMessage(value: string): OutputInfo;

    hasFieldsMap(): boolean;
    clearFieldsMap(): void;
    getFieldsMap(): google_protobuf_struct_pb.Struct | undefined;
    setFieldsMap(value?: google_protobuf_struct_pb.Struct): OutputInfo;

    hasParams(): boolean;
    clearParams(): void;
    getParams(): google_protobuf_struct_pb.Struct | undefined;
    setParams(value?: google_protobuf_struct_pb.Struct): OutputInfo;
    clearParamsSpecsList(): void;
    getParamsSpecsList(): Array<ModelTypeField>;
    setParamsSpecsList(value: Array<ModelTypeField>): OutputInfo;
    addParamsSpecs(value?: ModelTypeField, index?: number): ModelTypeField;

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

export namespace OutputInfo {
    export type AsObject = {
        data?: Data.AsObject,
        outputConfig?: OutputConfig.AsObject,
        message: string,
        fieldsMap?: google_protobuf_struct_pb.Struct.AsObject,
        params?: google_protobuf_struct_pb.Struct.AsObject,
        paramsSpecsList: Array<ModelTypeField.AsObject>,
    }
}

export class InputInfo extends jspb.Message { 

    hasFieldsMap(): boolean;
    clearFieldsMap(): void;
    getFieldsMap(): google_protobuf_struct_pb.Struct | undefined;
    setFieldsMap(value?: google_protobuf_struct_pb.Struct): InputInfo;

    hasParams(): boolean;
    clearParams(): void;
    getParams(): google_protobuf_struct_pb.Struct | undefined;
    setParams(value?: google_protobuf_struct_pb.Struct): InputInfo;

    hasBaseEmbedModel(): boolean;
    clearBaseEmbedModel(): void;
    getBaseEmbedModel(): Model | undefined;
    setBaseEmbedModel(value?: Model): InputInfo;

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

export namespace InputInfo {
    export type AsObject = {
        fieldsMap?: google_protobuf_struct_pb.Struct.AsObject,
        params?: google_protobuf_struct_pb.Struct.AsObject,
        baseEmbedModel?: Model.AsObject,
    }
}

export class TrainInfo extends jspb.Message { 

    hasParams(): boolean;
    clearParams(): void;
    getParams(): google_protobuf_struct_pb.Struct | undefined;
    setParams(value?: google_protobuf_struct_pb.Struct): TrainInfo;

    hasDataset(): boolean;
    clearDataset(): void;
    getDataset(): Dataset | undefined;
    setDataset(value?: Dataset): TrainInfo;

    hasResumeFromModel(): boolean;
    clearResumeFromModel(): void;
    getResumeFromModel(): Model | undefined;
    setResumeFromModel(value?: Model): TrainInfo;

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

export namespace TrainInfo {
    export type AsObject = {
        params?: google_protobuf_struct_pb.Struct.AsObject,
        dataset?: Dataset.AsObject,
        resumeFromModel?: Model.AsObject,
    }
}

export class EvalInfo extends jspb.Message { 

    hasParams(): boolean;
    clearParams(): void;
    getParams(): google_protobuf_struct_pb.Struct | undefined;
    setParams(value?: google_protobuf_struct_pb.Struct): EvalInfo;

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

export namespace EvalInfo {
    export type AsObject = {
        params?: google_protobuf_struct_pb.Struct.AsObject,
    }
}

export class ImportInfo extends jspb.Message { 

    hasParams(): boolean;
    clearParams(): void;
    getParams(): google_protobuf_struct_pb.Struct | undefined;
    setParams(value?: google_protobuf_struct_pb.Struct): ImportInfo;

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

export namespace ImportInfo {
    export type AsObject = {
        params?: google_protobuf_struct_pb.Struct.AsObject,
    }
}

export class OutputConfig extends jspb.Message { 
    getConceptsMutuallyExclusive(): boolean;
    setConceptsMutuallyExclusive(value: boolean): OutputConfig;
    getExistingModelId(): string;
    setExistingModelId(value: string): OutputConfig;
    getLanguage(): string;
    setLanguage(value: string): OutputConfig;
    getHyperParameters(): string;
    setHyperParameters(value: string): OutputConfig;
    getMaxConcepts(): number;
    setMaxConcepts(value: number): OutputConfig;
    getMinValue(): number;
    setMinValue(value: number): OutputConfig;
    clearSelectConceptsList(): void;
    getSelectConceptsList(): Array<Concept>;
    setSelectConceptsList(value: Array<Concept>): OutputConfig;
    addSelectConcepts(value?: Concept, index?: number): Concept;
    getTrainingTimeout(): number;
    setTrainingTimeout(value: number): OutputConfig;
    getSampleMs(): number;
    setSampleMs(value: number): OutputConfig;

    hasHyperParams(): boolean;
    clearHyperParams(): void;
    getHyperParams(): google_protobuf_struct_pb.Struct | undefined;
    setHyperParams(value?: google_protobuf_struct_pb.Struct): OutputConfig;
    getEmbedModelVersionId(): string;
    setEmbedModelVersionId(value: string): OutputConfig;
    getFailOnMissingPositiveExamples(): boolean;
    setFailOnMissingPositiveExamples(value: boolean): OutputConfig;

    hasModelMetadata(): boolean;
    clearModelMetadata(): void;
    getModelMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setModelMetadata(value?: google_protobuf_struct_pb.Struct): OutputConfig;

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

export namespace OutputConfig {
    export type AsObject = {
        conceptsMutuallyExclusive: boolean,
        existingModelId: string,
        language: string,
        hyperParameters: string,
        maxConcepts: number,
        minValue: number,
        selectConceptsList: Array<Concept.AsObject>,
        trainingTimeout: number,
        sampleMs: number,
        hyperParams?: google_protobuf_struct_pb.Struct.AsObject,
        embedModelVersionId: string,
        failOnMissingPositiveExamples: boolean,
        modelMetadata?: google_protobuf_struct_pb.Struct.AsObject,
    }
}

export class ModelType extends jspb.Message { 
    getId(): string;
    setId(value: string): ModelType;
    getTitle(): string;
    setTitle(value: string): ModelType;
    getDescription(): string;
    setDescription(value: string): ModelType;
    clearInputFieldsList(): void;
    getInputFieldsList(): Array<string>;
    setInputFieldsList(value: Array<string>): ModelType;
    addInputFields(value: string, index?: number): string;
    clearOutputFieldsList(): void;
    getOutputFieldsList(): Array<string>;
    setOutputFieldsList(value: Array<string>): ModelType;
    addOutputFields(value: string, index?: number): string;
    getTrainable(): boolean;
    setTrainable(value: boolean): ModelType;
    getCreatable(): boolean;
    setCreatable(value: boolean): ModelType;
    getInternalOnly(): boolean;
    setInternalOnly(value: boolean): ModelType;
    clearModelTypeFieldsList(): void;
    getModelTypeFieldsList(): Array<ModelTypeField>;
    setModelTypeFieldsList(value: Array<ModelTypeField>): ModelType;
    addModelTypeFields(value?: ModelTypeField, index?: number): ModelTypeField;
    getRequiresSequentialFrames(): boolean;
    setRequiresSequentialFrames(value: boolean): ModelType;
    clearExpectedInputLayersList(): void;
    getExpectedInputLayersList(): Array<ModelLayerInfo>;
    setExpectedInputLayersList(value: Array<ModelLayerInfo>): ModelType;
    addExpectedInputLayers(value?: ModelLayerInfo, index?: number): ModelLayerInfo;
    clearExpectedOutputLayersList(): void;
    getExpectedOutputLayersList(): Array<ModelLayerInfo>;
    setExpectedOutputLayersList(value: Array<ModelLayerInfo>): ModelType;
    addExpectedOutputLayers(value?: ModelLayerInfo, index?: number): ModelLayerInfo;
    getEvaluationType(): EvaluationType;
    setEvaluationType(value: EvaluationType): ModelType;
    clearMethodSignaturesList(): void;
    getMethodSignaturesList(): Array<MethodSignature>;
    setMethodSignaturesList(value: Array<MethodSignature>): ModelType;
    addMethodSignatures(value?: MethodSignature, index?: number): MethodSignature;

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

export namespace ModelType {
    export type AsObject = {
        id: string,
        title: string,
        description: string,
        inputFieldsList: Array<string>,
        outputFieldsList: Array<string>,
        trainable: boolean,
        creatable: boolean,
        internalOnly: boolean,
        modelTypeFieldsList: Array<ModelTypeField.AsObject>,
        requiresSequentialFrames: boolean,
        expectedInputLayersList: Array<ModelLayerInfo.AsObject>,
        expectedOutputLayersList: Array<ModelLayerInfo.AsObject>,
        evaluationType: EvaluationType,
        methodSignaturesList: Array<MethodSignature.AsObject>,
    }
}

export class ModelLayerInfo extends jspb.Message { 
    getDataFieldName(): string;
    setDataFieldName(value: string): ModelLayerInfo;
    clearShapesList(): void;
    getShapesList(): Array<LayerShape>;
    setShapesList(value: Array<LayerShape>): ModelLayerInfo;
    addShapes(value?: LayerShape, index?: number): LayerShape;
    getDescription(): string;
    setDescription(value: string): ModelLayerInfo;
    getRequiresLabelFilename(): boolean;
    setRequiresLabelFilename(value: boolean): ModelLayerInfo;

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

export namespace ModelLayerInfo {
    export type AsObject = {
        dataFieldName: string,
        shapesList: Array<LayerShape.AsObject>,
        description: string,
        requiresLabelFilename: boolean,
    }
}

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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 { 
    clearDimsList(): void;
    getDimsList(): Array<number>;
    setDimsList(value: Array<number>): LayerShape;
    addDims(value: number, index?: number): number;
    clearMaxDimsList(): void;
    getMaxDimsList(): Array<number>;
    setMaxDimsList(value: Array<number>): LayerShape;
    addMaxDims(value: number, index?: number): number;
    getDataType(): DataType;
    setDataType(value: DataType): LayerShape;
    getDescription(): string;
    setDescription(value: string): LayerShape;

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

export namespace LayerShape {
    export type AsObject = {
        dimsList: Array<number>,
        maxDimsList: Array<number>,
        dataType: DataType,
        description: string,
    }
}

export class ModelTypeField extends jspb.Message { 
    getPath(): string;
    setPath(value: string): ModelTypeField;
    getFieldType(): ModelTypeField.ModelTypeFieldType;
    setFieldType(value: ModelTypeField.ModelTypeFieldType): ModelTypeField;

    hasDefaultValue(): boolean;
    clearDefaultValue(): void;
    getDefaultValue(): google_protobuf_struct_pb.Value | undefined;
    setDefaultValue(value?: google_protobuf_struct_pb.Value): ModelTypeField;
    getDescription(): string;
    setDescription(value: string): ModelTypeField;
    getPlaceholder(): string;
    setPlaceholder(value: string): ModelTypeField;
    clearModelTypeEnumOptionsList(): void;
    getModelTypeEnumOptionsList(): Array<ModelTypeEnumOption>;
    setModelTypeEnumOptionsList(value: Array<ModelTypeEnumOption>): ModelTypeField;
    addModelTypeEnumOptions(value?: ModelTypeEnumOption, index?: number): ModelTypeEnumOption;
    getInternalOnly(): boolean;
    setInternalOnly(value: boolean): ModelTypeField;
    getRequired(): boolean;
    setRequired(value: boolean): ModelTypeField;

    hasModelTypeRangeInfo(): boolean;
    clearModelTypeRangeInfo(): void;
    getModelTypeRangeInfo(): ModelTypeRangeInfo | undefined;
    setModelTypeRangeInfo(value?: ModelTypeRangeInfo): ModelTypeField;
    getName(): string;
    setName(value: string): ModelTypeField;
    getType(): ModelTypeField.DataType;
    setType(value: ModelTypeField.DataType): ModelTypeField;
    clearTypeArgsList(): void;
    getTypeArgsList(): Array<ModelTypeField>;
    setTypeArgsList(value: Array<ModelTypeField>): ModelTypeField;
    addTypeArgs(value?: ModelTypeField, index?: number): ModelTypeField;
    getIterator(): boolean;
    setIterator(value: boolean): ModelTypeField;
    getDefault(): string;
    setDefault(value: string): ModelTypeField;
    getIsParam(): boolean;
    setIsParam(value: boolean): ModelTypeField;

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

export namespace ModelTypeField {
    export type AsObject = {
        path: string,
        fieldType: ModelTypeField.ModelTypeFieldType,
        defaultValue?: google_protobuf_struct_pb.Value.AsObject,
        description: string,
        placeholder: string,
        modelTypeEnumOptionsList: Array<ModelTypeEnumOption.AsObject>,
        internalOnly: boolean,
        required: boolean,
        modelTypeRangeInfo?: ModelTypeRangeInfo.AsObject,
        name: string,
        type: ModelTypeField.DataType,
        typeArgsList: Array<ModelTypeField.AsObject>,
        iterator: boolean,
        pb_default: string,
        isParam: boolean,
    }

    export enum ModelTypeFieldType {
    INVALID_MODEL_TYPE_FIELD_TYPE = 0,
    BOOLEAN = 1,
    STRING = 2,
    NUMBER = 3,
    ARRAY_OF_CONCEPTS = 4,
    ARRAY_OF_CONCEPTS_WITH_THRESHOLD = 5,
    RANGE = 7,
    ENUM = 8,
    COLLABORATORS = 9,
    JSON = 10,
    ARRAY_OF_NUMBERS = 11,
    WORKFLOW_EMBED_MODELS = 12,
    ARRAY_OF_STRINGS = 13,
    RECURSIVE_ENUM = 14,
    PYTHON_CODE = 15,
    DATASET_ID = 16,
    DATASET_VERSION_ID = 17,
    ARRAY_OF_MODEL_CONCEPTS = 18,
    DATASET = 19,
    DATASET_VERSION = 20,
    ENCRYPTED_STRING = 21,
    CHECKPOINT_MODEL = 22,
    ARRAY_OF_SECRETS = 23,
    }

    export enum DataType {
    NOT_SET = 0,
    STR = 1,
    BYTES = 2,
    INT = 3,
    FLOAT = 4,
    BOOL = 5,
    NDARRAY = 6,
    JSON_DATA = 7,
    TEXT = 8,
    IMAGE = 9,
    CONCEPT = 10,
    REGION = 11,
    FRAME = 12,
    AUDIO = 13,
    VIDEO = 14,
    NAMED_FIELDS = 15,
    TUPLE = 16,
    LIST = 17,
    }

}

export class ModelTypeRangeInfo extends jspb.Message { 
    getMin(): number;
    setMin(value: number): ModelTypeRangeInfo;
    getMax(): number;
    setMax(value: number): ModelTypeRangeInfo;
    getStep(): number;
    setStep(value: number): ModelTypeRangeInfo;

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

export namespace ModelTypeRangeInfo {
    export type AsObject = {
        min: number,
        max: number,
        step: number,
    }
}

export class ModelTypeEnumOption extends jspb.Message { 
    getId(): string;
    setId(value: string): ModelTypeEnumOption;
    clearAliasesList(): void;
    getAliasesList(): Array<ModelTypeEnumOptionAlias>;
    setAliasesList(value: Array<ModelTypeEnumOptionAlias>): ModelTypeEnumOption;
    addAliases(value?: ModelTypeEnumOptionAlias, index?: number): ModelTypeEnumOptionAlias;
    getDescription(): string;
    setDescription(value: string): ModelTypeEnumOption;
    clearModelTypeFieldsList(): void;
    getModelTypeFieldsList(): Array<ModelTypeField>;
    setModelTypeFieldsList(value: Array<ModelTypeField>): ModelTypeEnumOption;
    addModelTypeFields(value?: ModelTypeField, index?: number): ModelTypeField;
    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;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ModelTypeEnumOption, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ModelTypeEnumOption;
    static deserializeBinaryFromReader(message: ModelTypeEnumOption, reader: jspb.BinaryReader): ModelTypeEnumOption;
}

export namespace ModelTypeEnumOption {
    export type AsObject = {
        id: string,
        aliasesList: Array<ModelTypeEnumOptionAlias.AsObject>,
        description: string,
        modelTypeFieldsList: Array<ModelTypeField.AsObject>,
        internalOnly: boolean,
        recommended: boolean,
    }
}

export class ModelTypeEnumOptionAlias extends jspb.Message { 
    getIdInt(): number;
    setIdInt(value: number): ModelTypeEnumOptionAlias;
    getWildcardString(): string;
    setWildcardString(value: string): ModelTypeEnumOptionAlias;

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

export namespace ModelTypeEnumOptionAlias {
    export type AsObject = {
        idInt: number,
        wildcardString: string,
    }
}

export class ModelQuery extends jspb.Message { 
    getName(): string;
    setName(value: string): ModelQuery;
    getModelTypeId(): string;
    setModelTypeId(value: string): ModelQuery;

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

export namespace ModelQuery {
    export type AsObject = {
        name: string,
        modelTypeId: string,
    }
}

export class ModelVersion extends jspb.Message { 
    getId(): string;
    setId(value: string): ModelVersion;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): ModelVersion;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): ModelVersion;
    getActiveConceptCount(): number;
    setActiveConceptCount(value: number): ModelVersion;

    hasMetrics(): boolean;
    clearMetrics(): void;
    getMetrics(): EvalMetrics | undefined;
    setMetrics(value?: EvalMetrics): ModelVersion;
    getTotalInputCount(): number;
    setTotalInputCount(value: number): ModelVersion;

    hasPretrainedModelConfig(): boolean;
    clearPretrainedModelConfig(): void;
    getPretrainedModelConfig(): PretrainedModelConfig | undefined;
    setPretrainedModelConfig(value?: PretrainedModelConfig): ModelVersion;

    hasCompletedAt(): boolean;
    clearCompletedAt(): void;
    getCompletedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCompletedAt(value?: google_protobuf_timestamp_pb.Timestamp): ModelVersion;
    getDescription(): string;
    setDescription(value: string): ModelVersion;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): ModelVersion;
    getAppId(): string;
    setAppId(value: string): ModelVersion;
    getUserId(): string;
    setUserId(value: string): ModelVersion;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): ModelVersion;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): ModelVersion;
    getLicense(): string;
    setLicense(value: string): ModelVersion;

    hasOutputInfo(): boolean;
    clearOutputInfo(): void;
    getOutputInfo(): OutputInfo | undefined;
    setOutputInfo(value?: OutputInfo): ModelVersion;

    hasInputInfo(): boolean;
    clearInputInfo(): void;
    getInputInfo(): InputInfo | undefined;
    setInputInfo(value?: InputInfo): ModelVersion;

    hasTrainInfo(): boolean;
    clearTrainInfo(): void;
    getTrainInfo(): TrainInfo | undefined;
    setTrainInfo(value?: TrainInfo): ModelVersion;

    hasImportInfo(): boolean;
    clearImportInfo(): void;
    getImportInfo(): ImportInfo | undefined;
    setImportInfo(value?: ImportInfo): ModelVersion;
    getTrainLog(): string;
    setTrainLog(value: string): ModelVersion;

    hasInferenceComputeInfo(): boolean;
    clearInferenceComputeInfo(): void;
    getInferenceComputeInfo(): ComputeInfo | undefined;
    setInferenceComputeInfo(value?: ComputeInfo): ModelVersion;

    hasBuildInfo(): boolean;
    clearBuildInfo(): void;
    getBuildInfo(): BuildInfo | undefined;
    setBuildInfo(value?: BuildInfo): ModelVersion;
    clearMethodSignaturesList(): void;
    getMethodSignaturesList(): Array<MethodSignature>;
    setMethodSignaturesList(value: Array<MethodSignature>): ModelVersion;
    addMethodSignatures(value?: MethodSignature, index?: number): MethodSignature;
    clearSpecialHandlingList(): void;
    getSpecialHandlingList(): Array<SpecialHandling>;
    setSpecialHandlingList(value: Array<SpecialHandling>): ModelVersion;
    addSpecialHandling(value?: SpecialHandling, index?: number): SpecialHandling;
    getNumThreads(): number;
    setNumThreads(value: number): ModelVersion;

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

export namespace ModelVersion {
    export type AsObject = {
        id: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        activeConceptCount: number,
        metrics?: EvalMetrics.AsObject,
        totalInputCount: number,
        pretrainedModelConfig?: PretrainedModelConfig.AsObject,
        completedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        description: string,
        visibility?: Visibility.AsObject,
        appId: string,
        userId: string,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        license: string,
        outputInfo?: OutputInfo.AsObject,
        inputInfo?: InputInfo.AsObject,
        trainInfo?: TrainInfo.AsObject,
        importInfo?: ImportInfo.AsObject,
        trainLog: string,
        inferenceComputeInfo?: ComputeInfo.AsObject,
        buildInfo?: BuildInfo.AsObject,
        methodSignaturesList: Array<MethodSignature.AsObject>,
        specialHandlingList: Array<SpecialHandling.AsObject>,
        numThreads: number,
    }
}

export class MethodSignature extends jspb.Message { 
    getName(): string;
    setName(value: string): MethodSignature;
    getMethodType(): RunnerMethodType;
    setMethodType(value: RunnerMethodType): MethodSignature;
    getDescription(): string;
    setDescription(value: string): MethodSignature;
    clearInputFieldsList(): void;
    getInputFieldsList(): Array<ModelTypeField>;
    setInputFieldsList(value: Array<ModelTypeField>): MethodSignature;
    addInputFields(value?: ModelTypeField, index?: number): ModelTypeField;
    clearOutputFieldsList(): void;
    getOutputFieldsList(): Array<ModelTypeField>;
    setOutputFieldsList(value: Array<ModelTypeField>): MethodSignature;
    addOutputFields(value?: ModelTypeField, index?: number): ModelTypeField;

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

export namespace MethodSignature {
    export type AsObject = {
        name: string,
        methodType: RunnerMethodType,
        description: string,
        inputFieldsList: Array<ModelTypeField.AsObject>,
        outputFieldsList: Array<ModelTypeField.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;
    getPlatform(): string;
    setPlatform(value: string): BuildInfo;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): BuildInfo.AsObject;
    static toObject(includeInstance: boolean, msg: BuildInfo): BuildInfo.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
        platform: string,
    }
}

export class ModelVersionExport extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): 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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
    }
}

export class PretrainedModelConfig extends jspb.Message { 

    hasInputFieldsMap(): boolean;
    clearInputFieldsMap(): void;
    getInputFieldsMap(): google_protobuf_struct_pb.Struct | undefined;
    setInputFieldsMap(value?: google_protobuf_struct_pb.Struct): PretrainedModelConfig;

    hasOutputFieldsMap(): boolean;
    clearOutputFieldsMap(): void;
    getOutputFieldsMap(): google_protobuf_struct_pb.Struct | undefined;
    setOutputFieldsMap(value?: google_protobuf_struct_pb.Struct): PretrainedModelConfig;
    getModelZipUrl(): string;
    setModelZipUrl(value: string): PretrainedModelConfig;
    getLocalDev(): boolean;
    setLocalDev(value: boolean): PretrainedModelConfig;

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

export namespace PretrainedModelConfig {
    export type AsObject = {
        inputFieldsMap?: google_protobuf_struct_pb.Struct.AsObject,
        outputFieldsMap?: google_protobuf_struct_pb.Struct.AsObject,
        modelZipUrl: string,
        localDev: boolean,
    }
}

export class TrainStats extends jspb.Message { 
    clearLossCurveList(): void;
    getLossCurveList(): Array<LossCurveEntry>;
    setLossCurveList(value: Array<LossCurveEntry>): TrainStats;
    addLossCurve(value?: LossCurveEntry, index?: number): LossCurveEntry;

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

export namespace TrainStats {
    export type AsObject = {
        lossCurveList: Array<LossCurveEntry.AsObject>,
    }
}

export class LossCurveEntry extends jspb.Message { 
    getEpoch(): number;
    setEpoch(value: number): LossCurveEntry;
    getGlobalStep(): number;
    setGlobalStep(value: number): LossCurveEntry;
    getCost(): number;
    setCost(value: number): LossCurveEntry;

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

export namespace LossCurveEntry {
    export type AsObject = {
        epoch: number,
        globalStep: number,
        cost: number,
    }
}

export class LabelCount extends jspb.Message { 
    getConceptName(): string;
    setConceptName(value: string): LabelCount;
    getCount(): number;
    setCount(value: number): LabelCount;

    hasConcept(): boolean;
    clearConcept(): void;
    getConcept(): Concept | undefined;
    setConcept(value?: Concept): LabelCount;

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

export namespace LabelCount {
    export type AsObject = {
        conceptName: string,
        count: number,
        concept?: Concept.AsObject,
    }
}

export class LabelDistribution extends jspb.Message { 
    clearPositiveLabelCountsList(): void;
    getPositiveLabelCountsList(): Array<LabelCount>;
    setPositiveLabelCountsList(value: Array<LabelCount>): LabelDistribution;
    addPositiveLabelCounts(value?: LabelCount, index?: number): LabelCount;

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

export namespace LabelDistribution {
    export type AsObject = {
        positiveLabelCountsList: Array<LabelCount.AsObject>,
    }
}

export class CooccurrenceMatrixEntry extends jspb.Message { 
    getRow(): string;
    setRow(value: string): CooccurrenceMatrixEntry;
    getCol(): string;
    setCol(value: string): CooccurrenceMatrixEntry;
    getCount(): number;
    setCount(value: number): CooccurrenceMatrixEntry;

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

export namespace CooccurrenceMatrixEntry {
    export type AsObject = {
        row: string,
        col: string,
        count: number,
    }
}

export class CooccurrenceMatrix extends jspb.Message { 
    clearMatrixList(): void;
    getMatrixList(): Array<CooccurrenceMatrixEntry>;
    setMatrixList(value: Array<CooccurrenceMatrixEntry>): CooccurrenceMatrix;
    addMatrix(value?: CooccurrenceMatrixEntry, index?: number): CooccurrenceMatrixEntry;
    clearConceptIdsList(): void;
    getConceptIdsList(): Array<string>;
    setConceptIdsList(value: Array<string>): CooccurrenceMatrix;
    addConceptIds(value: string, index?: number): string;

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

export namespace CooccurrenceMatrix {
    export type AsObject = {
        matrixList: Array<CooccurrenceMatrixEntry.AsObject>,
        conceptIdsList: Array<string>,
    }
}

export class ConfusionMatrixEntry extends jspb.Message { 
    getPredicted(): string;
    setPredicted(value: string): ConfusionMatrixEntry;
    getActual(): string;
    setActual(value: string): ConfusionMatrixEntry;
    getValue(): number;
    setValue(value: number): ConfusionMatrixEntry;

    hasPredictedConcept(): boolean;
    clearPredictedConcept(): void;
    getPredictedConcept(): Concept | undefined;
    setPredictedConcept(value?: Concept): ConfusionMatrixEntry;

    hasActualConcept(): boolean;
    clearActualConcept(): void;
    getActualConcept(): Concept | undefined;
    setActualConcept(value?: Concept): ConfusionMatrixEntry;

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

export namespace ConfusionMatrixEntry {
    export type AsObject = {
        predicted: string,
        actual: string,
        value: number,
        predictedConcept?: Concept.AsObject,
        actualConcept?: Concept.AsObject,
    }
}

export class ConfusionMatrix extends jspb.Message { 
    clearMatrixList(): void;
    getMatrixList(): Array<ConfusionMatrixEntry>;
    setMatrixList(value: Array<ConfusionMatrixEntry>): ConfusionMatrix;
    addMatrix(value?: ConfusionMatrixEntry, index?: number): ConfusionMatrixEntry;
    clearConceptIdsList(): void;
    getConceptIdsList(): Array<string>;
    setConceptIdsList(value: Array<string>): ConfusionMatrix;
    addConceptIds(value: string, index?: number): string;

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

export namespace ConfusionMatrix {
    export type AsObject = {
        matrixList: Array<ConfusionMatrixEntry.AsObject>,
        conceptIdsList: Array<string>,
    }
}

export class ROC extends jspb.Message { 
    clearFprList(): void;
    getFprList(): Array<number>;
    setFprList(value: Array<number>): ROC;
    addFpr(value: number, index?: number): number;
    clearTprList(): void;
    getTprList(): Array<number>;
    setTprList(value: Array<number>): ROC;
    addTpr(value: number, index?: number): number;
    clearThresholdsList(): void;
    getThresholdsList(): Array<number>;
    setThresholdsList(value: Array<number>): ROC;
    addThresholds(value: number, index?: number): number;
    clearFprPerImageList(): void;
    getFprPerImageList(): Array<number>;
    setFprPerImageList(value: Array<number>): ROC;
    addFprPerImage(value: number, index?: number): number;
    clearFprPerObjectList(): void;
    getFprPerObjectList(): Array<number>;
    setFprPerObjectList(value: Array<number>): ROC;
    addFprPerObject(value: number, index?: number): number;

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

export namespace ROC {
    export type AsObject = {
        fprList: Array<number>,
        tprList: Array<number>,
        thresholdsList: Array<number>,
        fprPerImageList: Array<number>,
        fprPerObjectList: Array<number>,
    }
}

export class PrecisionRecallCurve extends jspb.Message { 
    clearRecallList(): void;
    getRecallList(): Array<number>;
    setRecallList(value: Array<number>): PrecisionRecallCurve;
    addRecall(value: number, index?: number): number;
    clearPrecisionList(): void;
    getPrecisionList(): Array<number>;
    setPrecisionList(value: Array<number>): PrecisionRecallCurve;
    addPrecision(value: number, index?: number): number;
    clearThresholdsList(): void;
    getThresholdsList(): Array<number>;
    setThresholdsList(value: Array<number>): PrecisionRecallCurve;
    addThresholds(value: number, index?: number): number;

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

export namespace PrecisionRecallCurve {
    export type AsObject = {
        recallList: Array<number>,
        precisionList: Array<number>,
        thresholdsList: Array<number>,
    }
}

export class BinaryMetrics extends jspb.Message { 
    getNumPos(): number;
    setNumPos(value: number): BinaryMetrics;
    getNumNeg(): number;
    setNumNeg(value: number): BinaryMetrics;
    getNumTot(): number;
    setNumTot(value: number): BinaryMetrics;
    getRocAuc(): number;
    setRocAuc(value: number): BinaryMetrics;
    getF1(): number;
    setF1(value: number): BinaryMetrics;

    hasConcept(): boolean;
    clearConcept(): void;
    getConcept(): Concept | undefined;
    setConcept(value?: Concept): BinaryMetrics;

    hasRocCurve(): boolean;
    clearRocCurve(): void;
    getRocCurve(): ROC | undefined;
    setRocCurve(value?: ROC): BinaryMetrics;

    hasPrecisionRecallCurve(): boolean;
    clearPrecisionRecallCurve(): void;
    getPrecisionRecallCurve(): PrecisionRecallCurve | undefined;
    setPrecisionRecallCurve(value?: PrecisionRecallCurve): BinaryMetrics;
    getAvgPrecision(): number;
    setAvgPrecision(value: number): BinaryMetrics;
    getAreaName(): string;
    setAreaName(value: string): BinaryMetrics;
    getAreaMin(): number;
    setAreaMin(value: number): BinaryMetrics;
    getAreaMax(): number;
    setAreaMax(value: number): BinaryMetrics;
    getIou(): number;
    setIou(value: number): BinaryMetrics;

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

export namespace BinaryMetrics {
    export type AsObject = {
        numPos: number,
        numNeg: number,
        numTot: number,
        rocAuc: number,
        f1: number,
        concept?: Concept.AsObject,
        rocCurve?: ROC.AsObject,
        precisionRecallCurve?: PrecisionRecallCurve.AsObject,
        avgPrecision: number,
        areaName: string,
        areaMin: number,
        areaMax: number,
        iou: number,
    }
}

export class TrackerMetrics extends jspb.Message { 
    getMotMota(): number;
    setMotMota(value: number): TrackerMetrics;
    getMotNumSwitches(): number;
    setMotNumSwitches(value: number): TrackerMetrics;
    getMorseFrag(): number;
    setMorseFrag(value: number): TrackerMetrics;
    getAvgPrecision(): number;
    setAvgPrecision(value: number): TrackerMetrics;
    getAiid(): string;
    setAiid(value: string): TrackerMetrics;
    getUniqueSwitchRate(): number;
    setUniqueSwitchRate(value: number): TrackerMetrics;

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

export namespace TrackerMetrics {
    export type AsObject = {
        motMota: number,
        motNumSwitches: number,
        morseFrag: number,
        avgPrecision: number,
        aiid: string,
        uniqueSwitchRate: number,
    }
}

export class EvalTestSetEntry extends jspb.Message { 

    hasInput(): boolean;
    clearInput(): void;
    getInput(): Input | undefined;
    setInput(value?: Input): EvalTestSetEntry;
    clearPredictedConceptsList(): void;
    getPredictedConceptsList(): Array<Concept>;
    setPredictedConceptsList(value: Array<Concept>): EvalTestSetEntry;
    addPredictedConcepts(value?: Concept, index?: number): Concept;
    clearGroundTruthConceptsList(): void;
    getGroundTruthConceptsList(): Array<Concept>;
    setGroundTruthConceptsList(value: Array<Concept>): EvalTestSetEntry;
    addGroundTruthConcepts(value?: Concept, index?: number): Concept;

    hasAnnotation(): boolean;
    clearAnnotation(): void;
    getAnnotation(): Annotation | undefined;
    setAnnotation(value?: Annotation): EvalTestSetEntry;

    hasPredictedAnnotation(): boolean;
    clearPredictedAnnotation(): void;
    getPredictedAnnotation(): Annotation | undefined;
    setPredictedAnnotation(value?: Annotation): EvalTestSetEntry;

    hasGroundTruthAnnotation(): boolean;
    clearGroundTruthAnnotation(): void;
    getGroundTruthAnnotation(): Annotation | undefined;
    setGroundTruthAnnotation(value?: Annotation): EvalTestSetEntry;

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

export namespace EvalTestSetEntry {
    export type AsObject = {
        input?: Input.AsObject,
        predictedConceptsList: Array<Concept.AsObject>,
        groundTruthConceptsList: Array<Concept.AsObject>,
        annotation?: Annotation.AsObject,
        predictedAnnotation?: Annotation.AsObject,
        groundTruthAnnotation?: Annotation.AsObject,
    }
}

export class MetricsSummary extends jspb.Message { 
    getTop1Accuracy(): number;
    setTop1Accuracy(value: number): MetricsSummary;
    getTop5Accuracy(): number;
    setTop5Accuracy(value: number): MetricsSummary;
    getMacroAvgRocAuc(): number;
    setMacroAvgRocAuc(value: number): MetricsSummary;
    getMacroStdRocAuc(): number;
    setMacroStdRocAuc(value: number): MetricsSummary;
    getMacroAvgF1Score(): number;
    setMacroAvgF1Score(value: number): MetricsSummary;
    getMacroStdF1Score(): number;
    setMacroStdF1Score(value: number): MetricsSummary;
    getMacroAvgPrecision(): number;
    setMacroAvgPrecision(value: number): MetricsSummary;
    getMacroAvgRecall(): number;
    setMacroAvgRecall(value: number): MetricsSummary;
    getMeanAvgPrecisionIou50(): number;
    setMeanAvgPrecisionIou50(value: number): MetricsSummary;
    getMeanAvgPrecisionIouRange(): number;
    setMeanAvgPrecisionIouRange(value: number): MetricsSummary;

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

export namespace MetricsSummary {
    export type AsObject = {
        top1Accuracy: number,
        top5Accuracy: number,
        macroAvgRocAuc: number,
        macroStdRocAuc: number,
        macroAvgF1Score: number,
        macroStdF1Score: number,
        macroAvgPrecision: number,
        macroAvgRecall: number,
        meanAvgPrecisionIou50: number,
        meanAvgPrecisionIouRange: number,
    }
}

export class EvalMetrics extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): EvalMetrics;
    getUserId(): string;
    setUserId(value: string): EvalMetrics;
    getAppId(): string;
    setAppId(value: string): EvalMetrics;
    getId(): string;
    setId(value: string): EvalMetrics;

    hasModel(): boolean;
    clearModel(): void;
    getModel(): Model | undefined;
    setModel(value?: Model): EvalMetrics;

    hasGroundTruthDataset(): boolean;
    clearGroundTruthDataset(): void;
    getGroundTruthDataset(): Dataset | undefined;
    setGroundTruthDataset(value?: Dataset): EvalMetrics;

    hasPredictionsDataset(): boolean;
    clearPredictionsDataset(): void;
    getPredictionsDataset(): Dataset | undefined;
    setPredictionsDataset(value?: Dataset): EvalMetrics;

    hasSummary(): boolean;
    clearSummary(): void;
    getSummary(): MetricsSummary | undefined;
    setSummary(value?: MetricsSummary): EvalMetrics;

    hasConfusionMatrix(): boolean;
    clearConfusionMatrix(): void;
    getConfusionMatrix(): ConfusionMatrix | undefined;
    setConfusionMatrix(value?: ConfusionMatrix): EvalMetrics;

    hasCooccurrenceMatrix(): boolean;
    clearCooccurrenceMatrix(): void;
    getCooccurrenceMatrix(): CooccurrenceMatrix | undefined;
    setCooccurrenceMatrix(value?: CooccurrenceMatrix): EvalMetrics;

    hasLabelCounts(): boolean;
    clearLabelCounts(): void;
    getLabelCounts(): LabelDistribution | undefined;
    setLabelCounts(value?: LabelDistribution): EvalMetrics;
    clearBinaryMetricsList(): void;
    getBinaryMetricsList(): Array<BinaryMetrics>;
    setBinaryMetricsList(value: Array<BinaryMetrics>): EvalMetrics;
    addBinaryMetrics(value?: BinaryMetrics, index?: number): BinaryMetrics;
    clearTestSetList(): void;
    getTestSetList(): Array<EvalTestSetEntry>;
    setTestSetList(value: Array<EvalTestSetEntry>): EvalMetrics;
    addTestSet(value?: EvalTestSetEntry, index?: number): EvalTestSetEntry;
    clearMetricsByAreaList(): void;
    getMetricsByAreaList(): Array<BinaryMetrics>;
    setMetricsByAreaList(value: Array<BinaryMetrics>): EvalMetrics;
    addMetricsByArea(value?: BinaryMetrics, index?: number): BinaryMetrics;
    clearMetricsByClassList(): void;
    getMetricsByClassList(): Array<BinaryMetrics>;
    setMetricsByClassList(value: Array<BinaryMetrics>): EvalMetrics;
    addMetricsByClass(value?: BinaryMetrics, index?: number): BinaryMetrics;
    clearTrackerMetricsList(): void;
    getTrackerMetricsList(): Array<TrackerMetrics>;
    setTrackerMetricsList(value: Array<TrackerMetrics>): EvalMetrics;
    addTrackerMetrics(value?: TrackerMetrics, index?: number): TrackerMetrics;

    hasEvalInfo(): boolean;
    clearEvalInfo(): void;
    getEvalInfo(): EvalInfo | undefined;
    setEvalInfo(value?: EvalInfo): EvalMetrics;

    hasExtendedMetrics(): boolean;
    clearExtendedMetrics(): void;
    getExtendedMetrics(): ExtendedMetrics | undefined;
    setExtendedMetrics(value?: ExtendedMetrics): EvalMetrics;

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

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,
        predictionsDataset?: Dataset.AsObject,
        summary?: MetricsSummary.AsObject,
        confusionMatrix?: ConfusionMatrix.AsObject,
        cooccurrenceMatrix?: CooccurrenceMatrix.AsObject,
        labelCounts?: LabelDistribution.AsObject,
        binaryMetricsList: Array<BinaryMetrics.AsObject>,
        testSetList: Array<EvalTestSetEntry.AsObject>,
        metricsByAreaList: Array<BinaryMetrics.AsObject>,
        metricsByClassList: Array<BinaryMetrics.AsObject>,
        trackerMetricsList: Array<TrackerMetrics.AsObject>,
        evalInfo?: EvalInfo.AsObject,
        extendedMetrics?: ExtendedMetrics.AsObject,
    }
}

export class ExtendedMetrics extends jspb.Message { 

    hasUserMetrics(): boolean;
    clearUserMetrics(): void;
    getUserMetrics(): google_protobuf_struct_pb.Struct | undefined;
    setUserMetrics(value?: google_protobuf_struct_pb.Struct): ExtendedMetrics;

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

export namespace ExtendedMetrics {
    export type AsObject = {
        userMetrics?: google_protobuf_struct_pb.Struct.AsObject,
    }
}

export class FieldsValue extends jspb.Message { 
    getConfusionMatrix(): boolean;
    setConfusionMatrix(value: boolean): FieldsValue;
    getCooccurrenceMatrix(): boolean;
    setCooccurrenceMatrix(value: boolean): FieldsValue;
    getLabelCounts(): boolean;
    setLabelCounts(value: boolean): FieldsValue;
    getBinaryMetrics(): boolean;
    setBinaryMetrics(value: boolean): FieldsValue;
    getTestSet(): boolean;
    setTestSet(value: boolean): FieldsValue;
    getMetricsByArea(): boolean;
    setMetricsByArea(value: boolean): FieldsValue;
    getMetricsByClass(): boolean;
    setMetricsByClass(value: boolean): FieldsValue;

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

export namespace FieldsValue {
    export type AsObject = {
        confusionMatrix: boolean,
        cooccurrenceMatrix: boolean,
        labelCounts: boolean,
        binaryMetrics: boolean,
        testSet: boolean,
        metricsByArea: boolean,
        metricsByClass: boolean,
    }
}

export class Output extends jspb.Message { 
    getId(): string;
    setId(value: string): Output;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): Output;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Output;

    hasModel(): boolean;
    clearModel(): void;
    getModel(): Model | undefined;
    setModel(value?: Model): Output;

    hasInput(): boolean;
    clearInput(): void;
    getInput(): Input | undefined;
    setInput(value?: Input): Output;

    hasData(): boolean;
    clearData(): void;
    getData(): Data | undefined;
    setData(value?: Data): Output;
    getPromptTokens(): number;
    setPromptTokens(value: number): Output;
    getCompletionTokens(): number;
    setCompletionTokens(value: number): Output;
    getCachedTokens(): number;
    setCachedTokens(value: number): Output;

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

export namespace Output {
    export type AsObject = {
        id: string,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        model?: Model.AsObject,
        input?: Input.AsObject,
        data?: Data.AsObject,
        promptTokens: number,
        completionTokens: number,
        cachedTokens: number,
    }
}

export class ScopeDeps extends jspb.Message { 
    getScope(): string;
    setScope(value: string): ScopeDeps;
    clearDependingScopesList(): void;
    getDependingScopesList(): Array<string>;
    setDependingScopesList(value: Array<string>): ScopeDeps;
    addDependingScopes(value: string, index?: number): string;

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

export namespace ScopeDeps {
    export type AsObject = {
        scope: string,
        dependingScopesList: Array<string>,
    }
}

export class EndpointDeps extends jspb.Message { 
    getEndpoint(): string;
    setEndpoint(value: string): EndpointDeps;
    clearDependingScopesList(): void;
    getDependingScopesList(): Array<string>;
    setDependingScopesList(value: Array<string>): EndpointDeps;
    addDependingScopes(value: string, index?: number): string;

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

export namespace EndpointDeps {
    export type AsObject = {
        endpoint: string,
        dependingScopesList: Array<string>,
    }
}

export class Hit extends jspb.Message { 
    getScore(): number;
    setScore(value: number): Hit;

    hasInput(): boolean;
    clearInput(): void;
    getInput(): Input | undefined;
    setInput(value?: Input): Hit;

    hasAnnotation(): boolean;
    clearAnnotation(): void;
    getAnnotation(): Annotation | undefined;
    setAnnotation(value?: Annotation): Hit;
    getUserId(): string;
    setUserId(value: string): Hit;
    getAppId(): string;
    setAppId(value: string): Hit;

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

export namespace Hit {
    export type AsObject = {
        score: number,
        input?: Input.AsObject,
        annotation?: Annotation.AsObject,
        userId: string,
        appId: string,
    }
}

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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 { 

    hasInput(): boolean;
    clearInput(): void;
    getInput(): Input | undefined;
    setInput(value?: Input): And;

    hasOutput(): boolean;
    clearOutput(): void;
    getOutput(): Output | undefined;
    setOutput(value?: Output): And;
    getNegate(): boolean;
    setNegate(value: boolean): And;

    hasAnnotation(): boolean;
    clearAnnotation(): void;
    getAnnotation(): Annotation | undefined;
    setAnnotation(value?: Annotation): And;

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

export namespace And {
    export type AsObject = {
        input?: Input.AsObject,
        output?: Output.AsObject,
        negate: boolean,
        annotation?: Annotation.AsObject,
    }
}

export class Query extends jspb.Message { 
    clearAndsList(): void;
    getAndsList(): Array<And>;
    setAndsList(value: Array<And>): Query;
    addAnds(value?: And, index?: number): And;
    getLanguage(): string;
    setLanguage(value: string): Query;
    clearFiltersList(): void;
    getFiltersList(): Array<Filter>;
    setFiltersList(value: Array<Filter>): Query;
    addFilters(value?: Filter, index?: number): Filter;
    clearRanksList(): void;
    getRanksList(): Array<Rank>;
    setRanksList(value: Array<Rank>): Query;
    addRanks(value?: Rank, index?: number): Rank;

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

export namespace Query {
    export type AsObject = {
        andsList: Array<And.AsObject>,
        language: string,
        filtersList: Array<Filter.AsObject>,
        ranksList: Array<Rank.AsObject>,
    }
}

export class Search extends jspb.Message { 

    hasQuery(): boolean;
    clearQuery(): void;
    getQuery(): Query | undefined;
    setQuery(value?: Query): Search;
    getId(): string;
    setId(value: string): Search;
    getApplicationId(): string;
    setApplicationId(value: string): Search;
    getName(): string;
    setName(value: string): Search;

    hasAsOf(): boolean;
    clearAsOf(): void;
    getAsOf(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setAsOf(value?: google_protobuf_timestamp_pb.Timestamp): Search;
    getGitHash(): string;
    setGitHash(value: string): Search;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Search;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Search;
    getAlgorithm(): string;
    setAlgorithm(value: string): Search;
    getSave(): boolean;
    setSave(value: boolean): Search;
    getMinValue(): number;
    setMinValue(value: number): Search;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): Search;
    getMetric(): Search.Metric;
    setMetric(value: Search.Metric): Search;

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

export namespace Search {
    export type AsObject = {
        query?: Query.AsObject,
        id: string,
        applicationId: string,
        name: string,
        asOf?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        gitHash: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        algorithm: string,
        save: boolean,
        minValue: number,
        visibility?: Visibility.AsObject,
        metric: Search.Metric,
    }

    export enum Metric {
    METRIC_NOT_SET = 0,
    EUCLIDEAN_DISTANCE = 1,
    COSINE_DISTANCE = 2,
    }

}

export class Filter extends jspb.Message { 
    getNegate(): boolean;
    setNegate(value: boolean): Filter;

    hasAnnotation(): boolean;
    clearAnnotation(): void;
    getAnnotation(): Annotation | undefined;
    setAnnotation(value?: Annotation): Filter;

    hasInput(): boolean;
    clearInput(): void;
    getInput(): Input | undefined;
    setInput(value?: Input): Filter;

    hasLastUpdatedTimeRange(): boolean;
    clearLastUpdatedTimeRange(): void;
    getLastUpdatedTimeRange(): TimeRange | undefined;
    setLastUpdatedTimeRange(value?: TimeRange): Filter;

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

export namespace Filter {
    export type AsObject = {
        negate: boolean,
        annotation?: Annotation.AsObject,
        input?: Input.AsObject,
        lastUpdatedTimeRange?: TimeRange.AsObject,
    }
}

export class TimeRange extends jspb.Message { 

    hasStartTime(): boolean;
    clearStartTime(): void;
    getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): TimeRange;

    hasEndTime(): boolean;
    clearEndTime(): void;
    getEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setEndTime(value?: google_protobuf_timestamp_pb.Timestamp): TimeRange;

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

export namespace TimeRange {
    export type AsObject = {
        startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class Rank extends jspb.Message { 
    getNegate(): boolean;
    setNegate(value: boolean): Rank;

    hasAnnotation(): boolean;
    clearAnnotation(): void;
    getAnnotation(): Annotation | undefined;
    setAnnotation(value?: Annotation): Rank;

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

export namespace Rank {
    export type AsObject = {
        negate: boolean,
        annotation?: Annotation.AsObject,
    }
}

export class Text extends jspb.Message { 
    getRaw(): string;
    setRaw(value: string): Text;
    getUrl(): string;
    setUrl(value: string): Text;
    getAllowDuplicateUrl(): boolean;
    setAllowDuplicateUrl(value: boolean): Text;

    hasHosted(): boolean;
    clearHosted(): void;
    getHosted(): HostedURL | undefined;
    setHosted(value?: HostedURL): Text;

    hasTextInfo(): boolean;
    clearTextInfo(): void;
    getTextInfo(): TextInfo | undefined;
    setTextInfo(value?: TextInfo): Text;

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

export namespace Text {
    export type AsObject = {
        raw: string,
        url: string,
        allowDuplicateUrl: boolean,
        hosted?: HostedURL.AsObject,
        textInfo?: TextInfo.AsObject,
    }
}

export class TextInfo extends jspb.Message { 
    getCharCount(): number;
    setCharCount(value: number): TextInfo;
    getEncoding(): string;
    setEncoding(value: string): TextInfo;

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

export namespace TextInfo {
    export type AsObject = {
        charCount: number,
        encoding: string,
    }
}

export class User extends jspb.Message { 
    getId(): string;
    setId(value: string): User;
    getPrimaryEmail(): string;
    setPrimaryEmail(value: string): User;
    getFirstName(): string;
    setFirstName(value: string): User;
    getLastName(): string;
    setLastName(value: string): User;
    getCompanyName(): string;
    setCompanyName(value: string): User;
    getJobTitle(): string;
    setJobTitle(value: string): User;
    getJobRole(): string;
    setJobRole(value: string): User;
    getIntention(): string;
    setIntention(value: string): User;
    getReferralSource(): string;
    setReferralSource(value: string): User;
    getBillType(): string;
    setBillType(value: string): User;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): User;

    hasDateGdprConsent(): boolean;
    clearDateGdprConsent(): void;
    getDateGdprConsent(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDateGdprConsent(value?: google_protobuf_timestamp_pb.Timestamp): User;

    hasDateTosConsent(): boolean;
    clearDateTosConsent(): void;
    getDateTosConsent(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDateTosConsent(value?: google_protobuf_timestamp_pb.Timestamp): User;

    hasDateMarketingConsent(): boolean;
    clearDateMarketingConsent(): void;
    getDateMarketingConsent(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDateMarketingConsent(value?: google_protobuf_timestamp_pb.Timestamp): User;

    hasDatePiiConsent(): boolean;
    clearDatePiiConsent(): void;
    getDatePiiConsent(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDatePiiConsent(value?: google_protobuf_timestamp_pb.Timestamp): User;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): User;
    clearEmailAddressesList(): void;
    getEmailAddressesList(): Array<EmailAddress>;
    setEmailAddressesList(value: Array<EmailAddress>): User;
    addEmailAddresses(value?: EmailAddress, index?: number): EmailAddress;
    getTwoFactorAuthEnabled(): boolean;
    setTwoFactorAuthEnabled(value: boolean): User;
    getTeamsCount(): number;
    setTeamsCount(value: number): User;
    getIsStarred(): boolean;
    setIsStarred(value: boolean): User;
    getStarCount(): number;
    setStarCount(value: number): User;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): User;

    hasUserDetail(): boolean;
    clearUserDetail(): void;
    getUserDetail(): UserDetail | undefined;
    setUserDetail(value?: UserDetail): User;

    hasImage(): boolean;
    clearImage(): void;
    getImage(): Image | undefined;
    setImage(value?: Image): User;

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

export namespace User {
    export type AsObject = {
        id: string,
        primaryEmail: string,
        firstName: string,
        lastName: string,
        companyName: string,
        jobTitle: string,
        jobRole: string,
        intention: string,
        referralSource: string,
        billType: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        dateGdprConsent?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        dateTosConsent?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        dateMarketingConsent?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        datePiiConsent?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        emailAddressesList: Array<EmailAddress.AsObject>,
        twoFactorAuthEnabled: boolean,
        teamsCount: number,
        isStarred: boolean,
        starCount: number,
        visibility?: Visibility.AsObject,
        userDetail?: UserDetail.AsObject,
        image?: Image.AsObject,
    }
}

export class UserDetail extends jspb.Message { 
    getPrimaryEmail(): string;
    setPrimaryEmail(value: string): UserDetail;
    getBillType(): string;
    setBillType(value: string): UserDetail;

    hasDateGdprConsent(): boolean;
    clearDateGdprConsent(): void;
    getDateGdprConsent(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDateGdprConsent(value?: google_protobuf_timestamp_pb.Timestamp): UserDetail;

    hasDateTosConsent(): boolean;
    clearDateTosConsent(): void;
    getDateTosConsent(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDateTosConsent(value?: google_protobuf_timestamp_pb.Timestamp): UserDetail;

    hasDateMarketingConsent(): boolean;
    clearDateMarketingConsent(): void;
    getDateMarketingConsent(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDateMarketingConsent(value?: google_protobuf_timestamp_pb.Timestamp): UserDetail;

    hasDatePiiConsent(): boolean;
    clearDatePiiConsent(): void;
    getDatePiiConsent(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDatePiiConsent(value?: google_protobuf_timestamp_pb.Timestamp): UserDetail;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): UserDetail;
    clearEmailAddressesList(): void;
    getEmailAddressesList(): Array<EmailAddress>;
    setEmailAddressesList(value: Array<EmailAddress>): UserDetail;
    addEmailAddresses(value?: EmailAddress, index?: number): EmailAddress;
    getTwoFactorAuthEnabled(): boolean;
    setTwoFactorAuthEnabled(value: boolean): UserDetail;
    getTeamsCount(): number;
    setTeamsCount(value: number): UserDetail;
    getCountry(): string;
    setCountry(value: string): UserDetail;
    getState(): string;
    setState(value: string): UserDetail;

    hasCommitmentValue(): boolean;
    clearCommitmentValue(): void;
    getCommitmentValue(): CommitmentValue | undefined;
    setCommitmentValue(value?: CommitmentValue): UserDetail;
    getPhoneVerified(): boolean;
    setPhoneVerified(value: boolean): UserDetail;

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

export namespace UserDetail {
    export type AsObject = {
        primaryEmail: string,
        billType: string,
        dateGdprConsent?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        dateTosConsent?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        dateMarketingConsent?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        datePiiConsent?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        emailAddressesList: Array<EmailAddress.AsObject>,
        twoFactorAuthEnabled: boolean,
        teamsCount: number,
        country: string,
        state: string,
        commitmentValue?: CommitmentValue.AsObject,
        phoneVerified: boolean,
    }
}

export class EmailAddress extends jspb.Message { 
    getEmail(): string;
    setEmail(value: string): EmailAddress;
    getPrimary(): boolean;
    setPrimary(value: boolean): EmailAddress;
    getVerified(): boolean;
    setVerified(value: boolean): EmailAddress;

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

export namespace EmailAddress {
    export type AsObject = {
        email: string,
        primary: boolean,
        verified: boolean,
    }
}

export class Password extends jspb.Message { 
    getPlaintext(): string;
    setPlaintext(value: string): Password;

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

export namespace Password {
    export type AsObject = {
        plaintext: string,
    }
}

export class PasswordViolations extends jspb.Message { 
    getMinimumLength(): boolean;
    setMinimumLength(value: boolean): PasswordViolations;
    getMaximumLength(): boolean;
    setMaximumLength(value: boolean): PasswordViolations;
    getUpperCaseNeeded(): boolean;
    setUpperCaseNeeded(value: boolean): PasswordViolations;
    getLowerCaseNeeded(): boolean;
    setLowerCaseNeeded(value: boolean): PasswordViolations;
    getNumericNeeded(): boolean;
    setNumericNeeded(value: boolean): PasswordViolations;
    getNonAlphanumericNeeded(): boolean;
    setNonAlphanumericNeeded(value: boolean): PasswordViolations;
    getPasswordReuse(): boolean;
    setPasswordReuse(value: boolean): PasswordViolations;
    getExcludeNames(): boolean;
    setExcludeNames(value: boolean): PasswordViolations;
    getExcludeEmail(): boolean;
    setExcludeEmail(value: boolean): PasswordViolations;
    getNoConfusingLetters(): boolean;
    setNoConfusingLetters(value: boolean): PasswordViolations;
    getNoSimplePasswords(): boolean;
    setNoSimplePasswords(value: boolean): PasswordViolations;
    getNoCommonVocabs(): boolean;
    setNoCommonVocabs(value: boolean): PasswordViolations;
    getNoOverlapWithOld(): boolean;
    setNoOverlapWithOld(value: boolean): PasswordViolations;
    getPasswordLifespan(): boolean;
    setPasswordLifespan(value: boolean): PasswordViolations;

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

export namespace PasswordViolations {
    export type AsObject = {
        minimumLength: boolean,
        maximumLength: boolean,
        upperCaseNeeded: boolean,
        lowerCaseNeeded: boolean,
        numericNeeded: boolean,
        nonAlphanumericNeeded: boolean,
        passwordReuse: boolean,
        excludeNames: boolean,
        excludeEmail: boolean,
        noConfusingLetters: boolean,
        noSimplePasswords: boolean,
        noCommonVocabs: boolean,
        noOverlapWithOld: boolean,
        passwordLifespan: boolean,
    }
}

export class CommitmentValue extends jspb.Message { 
    getValue(): number;
    setValue(value: number): CommitmentValue;
    getType(): CommitmentValue.CommitmentType;
    setType(value: CommitmentValue.CommitmentType): CommitmentValue;

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

export namespace CommitmentValue {
    export type AsObject = {
        value: number,
        type: CommitmentValue.CommitmentType,
    }

    export enum CommitmentType {
    TYPE_NOT_SET = 0,
    MONTHLY = 1,
    ANNUAL = 2,
    }

}

export class Video extends jspb.Message { 
    getUrl(): string;
    setUrl(value: string): Video;
    getBase64(): Uint8Array | string;
    getBase64_asU8(): Uint8Array;
    getBase64_asB64(): string;
    setBase64(value: Uint8Array | string): Video;
    getAllowDuplicateUrl(): boolean;
    setAllowDuplicateUrl(value: boolean): Video;
    getThumbnailUrl(): string;
    setThumbnailUrl(value: string): Video;

    hasHosted(): boolean;
    clearHosted(): void;
    getHosted(): HostedURL | undefined;
    setHosted(value?: HostedURL): Video;

    hasHostedThumbnail(): boolean;
    clearHostedThumbnail(): void;
    getHostedThumbnail(): HostedURL | undefined;
    setHostedThumbnail(value?: HostedURL): Video;

    hasVideoInfo(): boolean;
    clearVideoInfo(): void;
    getVideoInfo(): VideoInfo | undefined;
    setVideoInfo(value?: VideoInfo): Video;

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

export namespace Video {
    export type AsObject = {
        url: string,
        base64: Uint8Array | string,
        allowDuplicateUrl: boolean,
        thumbnailUrl: string,
        hosted?: HostedURL.AsObject,
        hostedThumbnail?: HostedURL.AsObject,
        videoInfo?: VideoInfo.AsObject,
    }
}

export class VideoInfo extends jspb.Message { 
    getWidth(): number;
    setWidth(value: number): VideoInfo;
    getHeight(): number;
    setHeight(value: number): VideoInfo;
    getFps(): number;
    setFps(value: number): VideoInfo;
    getVideoFormat(): string;
    setVideoFormat(value: string): VideoInfo;
    getBitRate(): number;
    setBitRate(value: number): VideoInfo;
    getFrameCount(): number;
    setFrameCount(value: number): VideoInfo;
    getDurationSeconds(): number;
    setDurationSeconds(value: number): VideoInfo;

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

export namespace VideoInfo {
    export type AsObject = {
        width: number,
        height: number,
        fps: number,
        videoFormat: string,
        bitRate: number,
        frameCount: number,
        durationSeconds: number,
    }
}

export class Workflow extends jspb.Message { 
    getId(): string;
    setId(value: string): Workflow;
    getAppId(): string;
    setAppId(value: string): Workflow;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Workflow;
    clearNodesList(): void;
    getNodesList(): Array<WorkflowNode>;
    setNodesList(value: Array<WorkflowNode>): Workflow;
    addNodes(value?: WorkflowNode, index?: number): WorkflowNode;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): Workflow;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): Workflow;
    getUserId(): string;
    setUserId(value: string): Workflow;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Workflow;

    hasVersion(): boolean;
    clearVersion(): void;
    getVersion(): WorkflowVersion | undefined;
    setVersion(value?: WorkflowVersion): Workflow;
    getIsStarred(): boolean;
    setIsStarred(value: boolean): Workflow;
    getStarCount(): number;
    setStarCount(value: number): Workflow;
    getDescription(): string;
    setDescription(value: string): Workflow;
    getNotes(): string;
    setNotes(value: string): Workflow;
    clearUseCasesList(): void;
    getUseCasesList(): Array<string>;
    setUseCasesList(value: Array<string>): Workflow;
    addUseCases(value: string, index?: number): string;
    clearCheckConsentsList(): void;
    getCheckConsentsList(): Array<string>;
    setCheckConsentsList(value: Array<string>): Workflow;
    addCheckConsents(value: string, index?: number): string;

    hasBookmarkOrigin(): boolean;
    clearBookmarkOrigin(): void;
    getBookmarkOrigin(): BookmarkOrigin | undefined;
    setBookmarkOrigin(value?: BookmarkOrigin): Workflow;

    hasImage(): boolean;
    clearImage(): void;
    getImage(): Image | undefined;
    setImage(value?: Image): Workflow;

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

export namespace Workflow {
    export type AsObject = {
        id: string,
        appId: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        nodesList: Array<WorkflowNode.AsObject>,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        visibility?: Visibility.AsObject,
        userId: string,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        version?: WorkflowVersion.AsObject,
        isStarred: boolean,
        starCount: number,
        description: string,
        notes: string,
        useCasesList: Array<string>,
        checkConsentsList: Array<string>,
        bookmarkOrigin?: BookmarkOrigin.AsObject,
        image?: Image.AsObject,
    }
}

export class WorkflowVersion extends jspb.Message { 
    getId(): string;
    setId(value: string): WorkflowVersion;
    getWorkflowId(): string;
    setWorkflowId(value: string): WorkflowVersion;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): WorkflowVersion;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): WorkflowVersion;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): WorkflowVersion;
    clearNodesList(): void;
    getNodesList(): Array<WorkflowNode>;
    setNodesList(value: Array<WorkflowNode>): WorkflowVersion;
    addNodes(value?: WorkflowNode, index?: number): WorkflowNode;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): WorkflowVersion;
    getAppId(): string;
    setAppId(value: string): WorkflowVersion;
    getUserId(): string;
    setUserId(value: string): WorkflowVersion;
    getDescription(): string;
    setDescription(value: string): WorkflowVersion;
    getLicense(): string;
    setLicense(value: string): WorkflowVersion;
    getIsDeprecated(): boolean;
    setIsDeprecated(value: boolean): WorkflowVersion;

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

export namespace WorkflowVersion {
    export type AsObject = {
        id: string,
        workflowId: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        visibility?: Visibility.AsObject,
        nodesList: Array<WorkflowNode.AsObject>,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        appId: string,
        userId: string,
        description: string,
        license: string,
        isDeprecated: boolean,
    }
}

export class WorkflowNode extends jspb.Message { 
    getId(): string;
    setId(value: string): WorkflowNode;

    hasModel(): boolean;
    clearModel(): void;
    getModel(): Model | undefined;
    setModel(value?: Model): WorkflowNode;
    clearNodeInputsList(): void;
    getNodeInputsList(): Array<NodeInput>;
    setNodeInputsList(value: Array<NodeInput>): WorkflowNode;
    addNodeInputs(value?: NodeInput, index?: number): NodeInput;
    getSuppressOutput(): boolean;
    setSuppressOutput(value: boolean): WorkflowNode;

    hasOutputInfoOverride(): boolean;
    clearOutputInfoOverride(): void;
    getOutputInfoOverride(): OutputInfo | undefined;
    setOutputInfoOverride(value?: OutputInfo): WorkflowNode;

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

export namespace WorkflowNode {
    export type AsObject = {
        id: string,
        model?: Model.AsObject,
        nodeInputsList: Array<NodeInput.AsObject>,
        suppressOutput: boolean,
        outputInfoOverride?: OutputInfo.AsObject,
    }
}

export class NodeInput extends jspb.Message { 
    getNodeId(): string;
    setNodeId(value: string): NodeInput;

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

export namespace NodeInput {
    export type AsObject = {
        nodeId: string,
    }
}

export class WorkflowResult extends jspb.Message { 
    getId(): string;
    setId(value: string): WorkflowResult;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): WorkflowResult;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): WorkflowResult;

    hasInput(): boolean;
    clearInput(): void;
    getInput(): Input | undefined;
    setInput(value?: Input): WorkflowResult;
    clearOutputsList(): void;
    getOutputsList(): Array<Output>;
    setOutputsList(value: Array<Output>): WorkflowResult;
    addOutputs(value?: Output, index?: number): Output;
    getSuppressOutput(): boolean;
    setSuppressOutput(value: boolean): WorkflowResult;

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

export namespace WorkflowResult {
    export type AsObject = {
        id: string,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        input?: Input.AsObject,
        outputsList: Array<Output.AsObject>,
        suppressOutput: boolean,
    }
}

export class WorkflowState extends jspb.Message { 
    getId(): string;
    setId(value: string): WorkflowState;

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

export namespace WorkflowState {
    export type AsObject = {
        id: string,
    }
}

export class AppDuplication extends jspb.Message { 
    getId(): string;
    setId(value: string): AppDuplication;

    hasDestinationApp(): boolean;
    clearDestinationApp(): void;
    getDestinationApp(): App | undefined;
    setDestinationApp(value?: App): AppDuplication;
    getExistingAppId(): string;
    setExistingAppId(value: string): AppDuplication;
    getNewAppId(): string;
    setNewAppId(value: string): AppDuplication;
    getNewAppName(): string;
    setNewAppName(value: string): AppDuplication;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): AppDuplication;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): AppDuplication;

    hasLastModifiedAt(): boolean;
    clearLastModifiedAt(): void;
    getLastModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setLastModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): AppDuplication;

    hasFilter(): boolean;
    clearFilter(): void;
    getFilter(): AppDuplicationFilters | undefined;
    setFilter(value?: AppDuplicationFilters): AppDuplication;
    clearProgressList(): void;
    getProgressList(): Array<AppCopyProgress>;
    setProgressList(value: Array<AppCopyProgress>): AppDuplication;
    addProgress(value?: AppCopyProgress, index?: number): AppCopyProgress;

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

export namespace AppDuplication {
    export type AsObject = {
        id: string,
        destinationApp?: App.AsObject,
        existingAppId: string,
        newAppId: string,
        newAppName: string,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        lastModifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        filter?: AppDuplicationFilters.AsObject,
        progressList: Array<AppCopyProgress.AsObject>,
    }
}

export class AppCopyProgress extends jspb.Message { 
    getField(): string;
    setField(value: string): AppCopyProgress;
    getValue(): number;
    setValue(value: number): AppCopyProgress;

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

export namespace AppCopyProgress {
    export type AsObject = {
        field: string,
        value: number,
    }
}

export class AppDuplicationFilters extends jspb.Message { 
    getCopyInputs(): boolean;
    setCopyInputs(value: boolean): AppDuplicationFilters;
    getCopyConcepts(): boolean;
    setCopyConcepts(value: boolean): AppDuplicationFilters;
    getCopyAnnotations(): boolean;
    setCopyAnnotations(value: boolean): AppDuplicationFilters;
    getCopyModels(): boolean;
    setCopyModels(value: boolean): AppDuplicationFilters;
    getCopyWorkflows(): boolean;
    setCopyWorkflows(value: boolean): AppDuplicationFilters;

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

export namespace AppDuplicationFilters {
    export type AsObject = {
        copyInputs: boolean,
        copyConcepts: boolean,
        copyAnnotations: boolean,
        copyModels: boolean,
        copyWorkflows: boolean,
    }
}

export class LabelOrder extends jspb.Message { 
    getId(): string;
    setId(value: string): LabelOrder;
    getName(): string;
    setName(value: string): LabelOrder;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): LabelOrder;
    getAutoRelease(): boolean;
    setAutoRelease(value: boolean): LabelOrder;
    getAllowEmptyTag(): boolean;
    setAllowEmptyTag(value: boolean): LabelOrder;

    hasDesiredFulfillTime(): boolean;
    clearDesiredFulfillTime(): void;
    getDesiredFulfillTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDesiredFulfillTime(value?: google_protobuf_timestamp_pb.Timestamp): LabelOrder;

    hasEstimateFulfillTime(): boolean;
    clearEstimateFulfillTime(): void;
    getEstimateFulfillTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setEstimateFulfillTime(value?: google_protobuf_timestamp_pb.Timestamp): LabelOrder;

    hasTask(): boolean;
    clearTask(): void;
    getTask(): Task | undefined;
    setTask(value?: Task): LabelOrder;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): LabelOrder;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): LabelOrder;

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

export namespace LabelOrder {
    export type AsObject = {
        id: string,
        name: string,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        autoRelease: boolean,
        allowEmptyTag: boolean,
        desiredFulfillTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        estimateFulfillTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        task?: Task.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class Task extends jspb.Message { 
    getId(): string;
    setId(value: string): Task;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Task;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Task;
    getType(): Task.TaskType;
    setType(value: Task.TaskType): Task;
    getDescription(): string;
    setDescription(value: string): Task;

    hasWorker(): boolean;
    clearWorker(): void;
    getWorker(): TaskWorker | undefined;
    setWorker(value?: TaskWorker): Task;
    clearConceptIdsList(): void;
    getConceptIdsList(): Array<string>;
    setConceptIdsList(value: Array<string>): Task;
    addConceptIds(value: string, index?: number): string;

    hasInputSource(): boolean;
    clearInputSource(): void;
    getInputSource(): TaskInputSource | undefined;
    setInputSource(value?: TaskInputSource): Task;
    getSampleMs(): number;
    setSampleMs(value: number): Task;

    hasAiAssistant(): boolean;
    clearAiAssistant(): void;
    getAiAssistant(): TaskAIAssistant | undefined;
    setAiAssistant(value?: TaskAIAssistant): Task;

    hasReview(): boolean;
    clearReview(): void;
    getReview(): TaskReview | undefined;
    setReview(value?: TaskReview): Task;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): Task;
    getName(): string;
    setName(value: string): Task;

    hasAiAssistParams(): boolean;
    clearAiAssistParams(): void;
    getAiAssistParams(): AiAssistParameters | undefined;
    setAiAssistParams(value?: AiAssistParameters): Task;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): Task;
    getAppId(): string;
    setAppId(value: string): Task;
    getUserId(): string;
    setUserId(value: string): Task;
    getLabelOrderId(): string;
    setLabelOrderId(value: string): Task;
    clearConceptsList(): void;
    getConceptsList(): Array<TaskConcept>;
    setConceptsList(value: Array<TaskConcept>): Task;
    addConcepts(value?: TaskConcept, index?: number): TaskConcept;
    getDeletePreviousAnnotations(): boolean;
    setDeletePreviousAnnotations(value: boolean): Task;

    hasMetrics(): boolean;
    clearMetrics(): void;
    getMetrics(): TaskMetrics | undefined;
    setMetrics(value?: TaskMetrics): Task;
    getPriority(): Task.TaskPriority;
    setPriority(value: Task.TaskPriority): Task;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): Task;

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

export namespace Task {
    export type AsObject = {
        id: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        type: Task.TaskType,
        description: string,
        worker?: TaskWorker.AsObject,
        conceptIdsList: Array<string>,
        inputSource?: TaskInputSource.AsObject,
        sampleMs: number,
        aiAssistant?: TaskAIAssistant.AsObject,
        review?: TaskReview.AsObject,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        name: string,
        aiAssistParams?: AiAssistParameters.AsObject,
        visibility?: Visibility.AsObject,
        appId: string,
        userId: string,
        labelOrderId: string,
        conceptsList: Array<TaskConcept.AsObject>,
        deletePreviousAnnotations: boolean,
        metrics?: TaskMetrics.AsObject,
        priority: Task.TaskPriority,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
    }

    export enum TaskType {
    TYPE_NOT_SET = 0,
    CONCEPTS_CLASSIFICATION = 1,
    BOUNDING_BOX_DETECTION = 2,
    POLYGON_DETECTION = 3,
    }

    export enum TaskPriority {
    TASK_PRIORITY_NOT_SET = 0,
    LOW = 1,
    MEDIUM = 2,
    HIGH = 3,
    }

}

export class AiAssistParameters extends jspb.Message { 
    getMinThreshold(): number;
    setMinThreshold(value: number): AiAssistParameters;
    getMaxThreshold(): number;
    setMaxThreshold(value: number): AiAssistParameters;
    clearConceptRelationIdsList(): void;
    getConceptRelationIdsList(): Array<string>;
    setConceptRelationIdsList(value: Array<string>): AiAssistParameters;
    addConceptRelationIds(value: string, index?: number): string;

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

export namespace AiAssistParameters {
    export type AsObject = {
        minThreshold: number,
        maxThreshold: number,
        conceptRelationIdsList: Array<string>,
    }
}

export class TaskWorker extends jspb.Message { 
    getStrategy(): TaskWorker.TaskWorkerStrategy;
    setStrategy(value: TaskWorker.TaskWorkerStrategy): TaskWorker;
    clearUserIdsList(): void;
    getUserIdsList(): Array<string>;
    setUserIdsList(value: Array<string>): TaskWorker;
    addUserIds(value: string, index?: number): string;
    clearUsersList(): void;
    getUsersList(): Array<User>;
    setUsersList(value: Array<User>): TaskWorker;
    addUsers(value?: User, index?: number): User;

    hasPartitionedStrategyInfo(): boolean;
    clearPartitionedStrategyInfo(): void;
    getPartitionedStrategyInfo(): TaskWorkerPartitionedStrategyInfo | undefined;
    setPartitionedStrategyInfo(value?: TaskWorkerPartitionedStrategyInfo): TaskWorker;
    clearWorkersList(): void;
    getWorkersList(): Array<Worker>;
    setWorkersList(value: Array<Worker>): TaskWorker;
    addWorkers(value?: Worker, index?: number): Worker;
    getType(): TaskWorker.WorkerType;
    setType(value: TaskWorker.WorkerType): TaskWorker;
    clearRunnerSelectorsList(): void;
    getRunnerSelectorsList(): Array<RunnerSelector>;
    setRunnerSelectorsList(value: Array<RunnerSelector>): TaskWorker;
    addRunnerSelectors(value?: RunnerSelector, index?: number): RunnerSelector;

    getStrategyInfoCase(): TaskWorker.StrategyInfoCase;

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

export namespace TaskWorker {
    export type AsObject = {
        strategy: TaskWorker.TaskWorkerStrategy,
        userIdsList: Array<string>,
        usersList: Array<User.AsObject>,
        partitionedStrategyInfo?: TaskWorkerPartitionedStrategyInfo.AsObject,
        workersList: Array<Worker.AsObject>,
        type: TaskWorker.WorkerType,
        runnerSelectorsList: Array<RunnerSelector.AsObject>,
    }

    export enum TaskWorkerStrategy {
    WORKER_STRATEGY_NOT_SET = 0,
    PARTITIONED = 2,
    FULL = 3,
    DYNAMIC = 4,
    }

    export enum WorkerType {
    WORKER_TYPE_NOT_SET = 0,
    WORKER_HUMAN = 1,
    WORKER_AUTO = 2,
    }


    export enum StrategyInfoCase {
        STRATEGY_INFO_NOT_SET = 0,
        PARTITIONED_STRATEGY_INFO = 3,
    }

}

export class TaskWorkerPartitionedStrategyInfo extends jspb.Message { 
    getType(): TaskWorkerPartitionedStrategyInfo.TaskWorkerPartitionedStrategy;
    setType(value: TaskWorkerPartitionedStrategyInfo.TaskWorkerPartitionedStrategy): TaskWorkerPartitionedStrategyInfo;
    getWorkersPerInput(): number;
    setWorkersPerInput(value: number): TaskWorkerPartitionedStrategyInfo;

    hasWeights(): boolean;
    clearWeights(): void;
    getWeights(): google_protobuf_struct_pb.Struct | undefined;
    setWeights(value?: google_protobuf_struct_pb.Struct): TaskWorkerPartitionedStrategyInfo;

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

export namespace TaskWorkerPartitionedStrategyInfo {
    export type AsObject = {
        type: TaskWorkerPartitionedStrategyInfo.TaskWorkerPartitionedStrategy,
        workersPerInput: number,
        weights?: google_protobuf_struct_pb.Struct.AsObject,
    }

    export enum TaskWorkerPartitionedStrategy {
    PARTITIONED_WORKER_STRATEGY_NOT_SET = 0,
    EVENLY = 1,
    WEIGHTED = 2,
    }

}

export class TaskInputSource extends jspb.Message { 
    getType(): TaskInputSource.TaskInputSourceType;
    setType(value: TaskInputSource.TaskInputSourceType): TaskInputSource;
    getId(): string;
    setId(value: string): TaskInputSource;

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

export namespace TaskInputSource {
    export type AsObject = {
        type: TaskInputSource.TaskInputSourceType,
        id: string,
    }

    export enum TaskInputSourceType {
    INPUT_SOURCE_TYPE_NOT_SET = 0,
    ALL_INPUTS = 1,
    SAVED_SEARCH = 2,
    DATASET = 3,
    INPUT = 4,
    }

}

export class TaskReview extends jspb.Message { 
    getStrategy(): TaskReview.TaskReviewStrategy;
    setStrategy(value: TaskReview.TaskReviewStrategy): TaskReview;
    clearUserIdsList(): void;
    getUserIdsList(): Array<string>;
    setUserIdsList(value: Array<string>): TaskReview;
    addUserIds(value: string, index?: number): string;
    clearUsersList(): void;
    getUsersList(): Array<User>;
    setUsersList(value: Array<User>): TaskReview;
    addUsers(value?: User, index?: number): User;

    hasManualStrategyInfo(): boolean;
    clearManualStrategyInfo(): void;
    getManualStrategyInfo(): TaskReviewManualStrategyInfo | undefined;
    setManualStrategyInfo(value?: TaskReviewManualStrategyInfo): TaskReview;

    hasConsensusStrategyInfo(): boolean;
    clearConsensusStrategyInfo(): void;
    getConsensusStrategyInfo(): TaskReviewConsensusStrategyInfo | undefined;
    setConsensusStrategyInfo(value?: TaskReviewConsensusStrategyInfo): TaskReview;

    getStrategyInfoCase(): TaskReview.StrategyInfoCase;

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

export namespace TaskReview {
    export type AsObject = {
        strategy: TaskReview.TaskReviewStrategy,
        userIdsList: Array<string>,
        usersList: Array<User.AsObject>,
        manualStrategyInfo?: TaskReviewManualStrategyInfo.AsObject,
        consensusStrategyInfo?: TaskReviewConsensusStrategyInfo.AsObject,
    }

    export enum TaskReviewStrategy {
    TASK_REVIEW_STRATEGY_NOT_SET = 0,
    NONE = 1,
    MANUAL = 2,
    CONSENSUS = 3,
    }


    export enum StrategyInfoCase {
        STRATEGY_INFO_NOT_SET = 0,
        MANUAL_STRATEGY_INFO = 3,
        CONSENSUS_STRATEGY_INFO = 4,
    }

}

export class TaskReviewManualStrategyInfo extends jspb.Message { 
    getSamplePercentage(): number;
    setSamplePercentage(value: number): TaskReviewManualStrategyInfo;
    getApprovalThreshold(): number;
    setApprovalThreshold(value: number): TaskReviewManualStrategyInfo;

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

export namespace TaskReviewManualStrategyInfo {
    export type AsObject = {
        samplePercentage: number,
        approvalThreshold: number,
    }
}

export class TaskReviewConsensusStrategyInfo extends jspb.Message { 
    getApprovalThreshold(): number;
    setApprovalThreshold(value: number): TaskReviewConsensusStrategyInfo;
    getApprovalThresholdLabelers(): number;
    setApprovalThresholdLabelers(value: number): TaskReviewConsensusStrategyInfo;
    getApprovalThresholdReviewers(): number;
    setApprovalThresholdReviewers(value: number): TaskReviewConsensusStrategyInfo;

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

export namespace TaskReviewConsensusStrategyInfo {
    export type AsObject = {
        approvalThreshold: number,
        approvalThresholdLabelers: number,
        approvalThresholdReviewers: number,
    }
}

export class TaskAIAssistant extends jspb.Message { 
    getWorkflowId(): string;
    setWorkflowId(value: string): TaskAIAssistant;

    hasWorkflow(): boolean;
    clearWorkflow(): void;
    getWorkflow(): Workflow | undefined;
    setWorkflow(value?: Workflow): TaskAIAssistant;

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

export namespace TaskAIAssistant {
    export type AsObject = {
        workflowId: string,
        workflow?: Workflow.AsObject,
    }
}

export class TaskAssignment extends jspb.Message { 
    getId(): string;
    setId(value: string): TaskAssignment;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): TaskAssignment;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): TaskAssignment;

    hasWorker(): boolean;
    clearWorker(): void;
    getWorker(): Worker | undefined;
    setWorker(value?: Worker): TaskAssignment;

    hasInput(): boolean;
    clearInput(): void;
    getInput(): Input | undefined;
    setInput(value?: Input): TaskAssignment;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): TaskAssignment;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): TaskAssignment.AsObject;
    static toObject(includeInstance: boolean, msg: TaskAssignment): TaskAssignment.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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;
    getPending(): number;
    setPending(value: number): TaskStatusCountPerUser;
    getAwaitingReview(): number;
    setAwaitingReview(value: number): TaskStatusCountPerUser;
    getSuccess(): number;
    setSuccess(value: number): TaskStatusCountPerUser;
    getReviewDenied(): number;
    setReviewDenied(value: number): TaskStatusCountPerUser;
    getAwaitingConsensusReview(): number;
    setAwaitingConsensusReview(value: number): TaskStatusCountPerUser;

    hasWorker(): boolean;
    clearWorker(): void;
    getWorker(): Worker | undefined;
    setWorker(value?: Worker): TaskStatusCountPerUser;

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

export namespace TaskStatusCountPerUser {
    export type AsObject = {
        userId: string,
        pending: number,
        awaitingReview: number,
        success: number,
        reviewDenied: number,
        awaitingConsensusReview: number,
        worker?: Worker.AsObject,
    }
}

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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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;

    hasThresholdRange(): boolean;
    clearThresholdRange(): void;
    getThresholdRange(): ThresholdRange | undefined;
    setThresholdRange(value?: ThresholdRange): TaskConceptAutoAnnotationConfig;
    getStatusCode(): proto_clarifai_api_status_status_code_pb.StatusCode;
    setStatusCode(value: proto_clarifai_api_status_status_code_pb.StatusCode): TaskConceptAutoAnnotationConfig;

    hasTimeOfDayRange(): boolean;
    clearTimeOfDayRange(): void;
    getTimeOfDayRange(): proto_clarifai_api_utils_time_pb.TimeOfDayRange | undefined;
    setTimeOfDayRange(value?: proto_clarifai_api_utils_time_pb.TimeOfDayRange): TaskConceptAutoAnnotationConfig;

    hasPolygon(): boolean;
    clearPolygon(): void;
    getPolygon(): Polygon | undefined;
    setPolygon(value?: Polygon): TaskConceptAutoAnnotationConfig;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): TaskConceptAutoAnnotationConfig.AsObject;
    static toObject(includeInstance: boolean, msg: TaskConceptAutoAnnotationConfig): TaskConceptAutoAnnotationConfig.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
        timeOfDayRange?: proto_clarifai_api_utils_time_pb.TimeOfDayRange.AsObject,
        polygon?: Polygon.AsObject,
    }
}

export class TaskConcept extends jspb.Message { 

    hasConcept(): boolean;
    clearConcept(): void;
    getConcept(): Concept | undefined;
    setConcept(value?: Concept): TaskConcept;

    hasAutoAnnotationConfig(): boolean;
    clearAutoAnnotationConfig(): void;
    getAutoAnnotationConfig(): TaskConceptAutoAnnotationConfig | undefined;
    setAutoAnnotationConfig(value?: TaskConceptAutoAnnotationConfig): TaskConcept;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): TaskConcept.AsObject;
    static toObject(includeInstance: boolean, msg: TaskConcept): TaskConcept.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 TaskMetrics extends jspb.Message { 

    hasWork(): boolean;
    clearWork(): void;
    getWork(): TaskWorkMetrics | undefined;
    setWork(value?: TaskWorkMetrics): TaskMetrics;

    hasReview(): boolean;
    clearReview(): void;
    getReview(): TaskReviewMetrics | undefined;
    setReview(value?: TaskReviewMetrics): TaskMetrics;

    hasInputSource(): boolean;
    clearInputSource(): void;
    getInputSource(): TaskInputSourceMetrics | undefined;
    setInputSource(value?: TaskInputSourceMetrics): TaskMetrics;

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

export namespace TaskMetrics {
    export type AsObject = {
        work?: TaskWorkMetrics.AsObject,
        review?: TaskReviewMetrics.AsObject,
        inputSource?: TaskInputSourceMetrics.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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
    }
}

export class TaskReviewMetrics extends jspb.Message { 
    getInputsCountEstimated(): number;
    setInputsCountEstimated(value: number): TaskReviewMetrics;
    getInputsPercentEstimated(): number;
    setInputsPercentEstimated(value: number): TaskReviewMetrics;
    clearInputsCountEstimatedPerReviewerList(): void;
    getInputsCountEstimatedPerReviewerList(): Array<number>;
    setInputsCountEstimatedPerReviewerList(value: Array<number>): TaskReviewMetrics;
    addInputsCountEstimatedPerReviewer(value: number, index?: number): number;
    clearInputsReviewableCountEstimatedPerReviewerList(): void;
    getInputsReviewableCountEstimatedPerReviewerList(): Array<number>;
    setInputsReviewableCountEstimatedPerReviewerList(value: Array<number>): TaskReviewMetrics;
    addInputsReviewableCountEstimatedPerReviewer(value: number, index?: number): number;
    clearInputsPercentEstimatedPerReviewerList(): void;
    getInputsPercentEstimatedPerReviewerList(): Array<number>;
    setInputsPercentEstimatedPerReviewerList(value: Array<number>): TaskReviewMetrics;
    addInputsPercentEstimatedPerReviewer(value: number, index?: number): number;

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

export namespace TaskReviewMetrics {
    export type AsObject = {
        inputsCountEstimated: number,
        inputsPercentEstimated: number,
        inputsCountEstimatedPerReviewerList: Array<number>,
        inputsReviewableCountEstimatedPerReviewerList: Array<number>,
        inputsPercentEstimatedPerReviewerList: Array<number>,
    }
}

export class TaskInputSourceMetrics extends jspb.Message { 
    getInputsCountEstimated(): number;
    setInputsCountEstimated(value: number): TaskInputSourceMetrics;

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

export namespace TaskInputSourceMetrics {
    export type AsObject = {
        inputsCountEstimated: number,
    }
}

export class Role extends jspb.Message { 
    getId(): string;
    setId(value: string): Role;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Role;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Role;
    getName(): string;
    setName(value: string): Role;
    getDescription(): string;
    setDescription(value: string): Role;
    clearScopesList(): void;
    getScopesList(): Array<string>;
    setScopesList(value: Array<string>): Role;
    addScopes(value: string, index?: number): string;
    clearEndpointsList(): void;
    getEndpointsList(): Array<string>;
    setEndpointsList(value: Array<string>): Role;
    addEndpoints(value: string, index?: number): string;
    getType(): RoleType;
    setType(value: RoleType): Role;

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

export namespace Role {
    export type AsObject = {
        id: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        name: string,
        description: string,
        scopesList: Array<string>,
        endpointsList: Array<string>,
        type: RoleType,
    }
}

export class Team extends jspb.Message { 
    getId(): string;
    setId(value: string): Team;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Team;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Team;
    getName(): string;
    setName(value: string): Team;
    getDefaultRoleId(): string;
    setDefaultRoleId(value: string): Team;

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

export namespace Team {
    export type AsObject = {
        id: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        name: string,
        defaultRoleId: string,
    }
}

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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 { 
    clearDuplicateCfidList(): void;
    getDuplicateCfidList(): Array<string>;
    setDuplicateCfidList(value: Array<string>): DuplicateAnnotationsResults;
    addDuplicateCfid(value: string, index?: number): string;
    getUniqueCount(): number;
    setUniqueCount(value: number): DuplicateAnnotationsResults;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): DuplicateAnnotationsResults.AsObject;
    static toObject(includeInstance: boolean, msg: DuplicateAnnotationsResults): DuplicateAnnotationsResults.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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;

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

export namespace Visibility {
    export type AsObject = {
        gettable: Visibility.Gettable,
    }

    export enum Gettable {
    UNKNOWN_VISIBILITY = 0,
    PRIVATE = 10,
    ORG = 30,
    PUBLIC = 50,
    }

}

export class FullTag extends jspb.Message { 
    getName(): string;
    setName(value: string): FullTag;
    getId(): string;
    setId(value: string): FullTag;

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

export namespace FullTag {
    export type AsObject = {
        name: string,
        id: string,
    }
}

export class TimeSegment extends jspb.Message { 
    getId(): string;
    setId(value: string): TimeSegment;

    hasData(): boolean;
    clearData(): void;
    getData(): Data | undefined;
    setData(value?: Data): TimeSegment;

    hasTimeInfo(): boolean;
    clearTimeInfo(): void;
    getTimeInfo(): TimeInfo | undefined;
    setTimeInfo(value?: TimeInfo): TimeSegment;

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

export namespace TimeSegment {
    export type AsObject = {
        id: string,
        data?: Data.AsObject,
        timeInfo?: TimeInfo.AsObject,
    }
}

export class TimeInfo extends jspb.Message { 
    getNumFrames(): number;
    setNumFrames(value: number): TimeInfo;
    getBeginTime(): number;
    setBeginTime(value: number): TimeInfo;
    getEndTime(): number;
    setEndTime(value: number): TimeInfo;

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

export namespace TimeInfo {
    export type AsObject = {
        numFrames: number,
        beginTime: number,
        endTime: number,
    }
}

export class BulkOperation extends jspb.Message { 
    getId(): string;
    setId(value: string): BulkOperation;

    hasInputIds(): boolean;
    clearInputIds(): void;
    getInputIds(): InputIDs | undefined;
    setInputIds(value?: InputIDs): BulkOperation;

    hasSearch(): boolean;
    clearSearch(): void;
    getSearch(): Search | undefined;
    setSearch(value?: Search): BulkOperation;

    hasDataset(): boolean;
    clearDataset(): void;
    getDataset(): Dataset | undefined;
    setDataset(value?: Dataset): BulkOperation;

    hasAnnotationSearch(): boolean;
    clearAnnotationSearch(): void;
    getAnnotationSearch(): Search | undefined;
    setAnnotationSearch(value?: Search): BulkOperation;

    hasOperation(): boolean;
    clearOperation(): void;
    getOperation(): Operation | undefined;
    setOperation(value?: Operation): BulkOperation;
    getAppId(): string;
    setAppId(value: string): BulkOperation;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): BulkOperation;

    hasProgress(): boolean;
    clearProgress(): void;
    getProgress(): Progress | undefined;
    setProgress(value?: Progress): BulkOperation;
    getCreatedBy(): string;
    setCreatedBy(value: string): BulkOperation;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): BulkOperation;

    hasLastModifiedAt(): boolean;
    clearLastModifiedAt(): void;
    getLastModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setLastModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): BulkOperation;

    getInputSourceCase(): BulkOperation.InputSourceCase;
    getAnnotationSourceCase(): BulkOperation.AnnotationSourceCase;

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

export namespace BulkOperation {
    export type AsObject = {
        id: string,
        inputIds?: InputIDs.AsObject,
        search?: Search.AsObject,
        dataset?: Dataset.AsObject,
        annotationSearch?: Search.AsObject,
        operation?: Operation.AsObject,
        appId: string,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        progress?: Progress.AsObject,
        createdBy: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        lastModifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }

    export enum InputSourceCase {
        INPUT_SOURCE_NOT_SET = 0,
        INPUT_IDS = 2,
        SEARCH = 10,
        DATASET = 11,
    }

    export enum AnnotationSourceCase {
        ANNOTATION_SOURCE_NOT_SET = 0,
        ANNOTATION_SEARCH = 12,
    }

}

export class InputIDs extends jspb.Message { 
    clearInputIdsList(): void;
    getInputIdsList(): Array<string>;
    setInputIdsList(value: Array<string>): InputIDs;
    addInputIds(value: string, index?: number): string;

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

export namespace InputIDs {
    export type AsObject = {
        inputIdsList: Array<string>,
    }
}

export class Progress extends jspb.Message { 
    getProcessed(): number;
    setProcessed(value: number): Progress;
    getLastProcessedId(): string;
    setLastProcessedId(value: string): Progress;

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

export namespace Progress {
    export type AsObject = {
        processed: number,
        lastProcessedId: string,
    }
}

export class Operation extends jspb.Message { 

    hasAddConcepts(): boolean;
    clearAddConcepts(): void;
    getAddConcepts(): AddConcepts | undefined;
    setAddConcepts(value?: AddConcepts): Operation;

    hasDeleteConcepts(): boolean;
    clearDeleteConcepts(): void;
    getDeleteConcepts(): DeleteConcepts | undefined;
    setDeleteConcepts(value?: DeleteConcepts): Operation;

    hasAddMetadata(): boolean;
    clearAddMetadata(): void;
    getAddMetadata(): AddMetadata | undefined;
    setAddMetadata(value?: AddMetadata): Operation;

    hasDeleteMetadata(): boolean;
    clearDeleteMetadata(): void;
    getDeleteMetadata(): DeleteMetadata | undefined;
    setDeleteMetadata(value?: DeleteMetadata): Operation;

    hasOverwriteGeo(): boolean;
    clearOverwriteGeo(): void;
    getOverwriteGeo(): OverwriteGeo | undefined;
    setOverwriteGeo(value?: OverwriteGeo): Operation;

    hasDeleteGeo(): boolean;
    clearDeleteGeo(): void;
    getDeleteGeo(): DeleteGeo | undefined;
    setDeleteGeo(value?: DeleteGeo): Operation;

    hasDeleteFromDataset(): boolean;
    clearDeleteFromDataset(): void;
    getDeleteFromDataset(): DeleteFromDataset | undefined;
    setDeleteFromDataset(value?: DeleteFromDataset): Operation;

    hasAddToDataset(): boolean;
    clearAddToDataset(): void;
    getAddToDataset(): AddToDataset | undefined;
    setAddToDataset(value?: AddToDataset): Operation;

    hasSplitIntoDatasets(): boolean;
    clearSplitIntoDatasets(): void;
    getSplitIntoDatasets(): SplitIntoDatasets | undefined;
    setSplitIntoDatasets(value?: SplitIntoDatasets): Operation;

    hasDeleteAnnotations(): boolean;
    clearDeleteAnnotations(): void;
    getDeleteAnnotations(): DeleteAnnotations | undefined;
    setDeleteAnnotations(value?: DeleteAnnotations): Operation;

    getOperationCase(): Operation.OperationCase;
    getAnnotationOperationCase(): Operation.AnnotationOperationCase;

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

export namespace Operation {
    export type AsObject = {
        addConcepts?: AddConcepts.AsObject,
        deleteConcepts?: DeleteConcepts.AsObject,
        addMetadata?: AddMetadata.AsObject,
        deleteMetadata?: DeleteMetadata.AsObject,
        overwriteGeo?: OverwriteGeo.AsObject,
        deleteGeo?: DeleteGeo.AsObject,
        deleteFromDataset?: DeleteFromDataset.AsObject,
        addToDataset?: AddToDataset.AsObject,
        splitIntoDatasets?: SplitIntoDatasets.AsObject,
        deleteAnnotations?: DeleteAnnotations.AsObject,
    }

    export enum OperationCase {
        OPERATION_NOT_SET = 0,
        ADD_CONCEPTS = 1,
        DELETE_CONCEPTS = 2,
        ADD_METADATA = 3,
        DELETE_METADATA = 4,
        OVERWRITE_GEO = 5,
        DELETE_GEO = 6,
        DELETE_FROM_DATASET = 7,
        ADD_TO_DATASET = 8,
        SPLIT_INTO_DATASETS = 9,
    }

    export enum AnnotationOperationCase {
        ANNOTATION_OPERATION_NOT_SET = 0,
        DELETE_ANNOTATIONS = 10,
    }

}

export class AddConcepts extends jspb.Message { 
    clearConceptsList(): void;
    getConceptsList(): Array<Concept>;
    setConceptsList(value: Array<Concept>): AddConcepts;
    addConcepts(value?: Concept, index?: number): Concept;

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

export namespace AddConcepts {
    export type AsObject = {
        conceptsList: Array<Concept.AsObject>,
    }
}

export class DeleteConcepts extends jspb.Message { 
    clearConceptsList(): void;
    getConceptsList(): Array<Concept>;
    setConceptsList(value: Array<Concept>): DeleteConcepts;
    addConcepts(value?: Concept, index?: number): Concept;
    clearUserIdsList(): void;
    getUserIdsList(): Array<string>;
    setUserIdsList(value: Array<string>): DeleteConcepts;
    addUserIds(value: string, index?: number): string;

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

export namespace DeleteConcepts {
    export type AsObject = {
        conceptsList: Array<Concept.AsObject>,
        userIdsList: Array<string>,
    }
}

export class AddMetadata extends jspb.Message { 

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): AddMetadata;

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

export namespace AddMetadata {
    export type AsObject = {
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
    }
}

export class DeleteMetadata extends jspb.Message { 

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): DeleteMetadata;

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

export namespace DeleteMetadata {
    export type AsObject = {
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
    }
}

export class OverwriteGeo extends jspb.Message { 

    hasGeo(): boolean;
    clearGeo(): void;
    getGeo(): Geo | undefined;
    setGeo(value?: Geo): OverwriteGeo;

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

export namespace OverwriteGeo {
    export type AsObject = {
        geo?: Geo.AsObject,
    }
}

export class DeleteGeo extends jspb.Message { 

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

export namespace DeleteGeo {
    export type AsObject = {
    }
}

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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 { 
    clearDatasetSplitsList(): void;
    getDatasetSplitsList(): Array<DatasetSplit>;
    setDatasetSplitsList(value: Array<DatasetSplit>): 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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 { 

    hasDataset(): boolean;
    clearDataset(): void;
    getDataset(): Dataset | undefined;
    setDataset(value?: Dataset): DatasetSplit;

    hasPercentage(): boolean;
    clearPercentage(): void;
    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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 DeleteAnnotations extends jspb.Message { 

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

export namespace DeleteAnnotations {
    export type AsObject = {
    }
}

export class InputsAddJob extends jspb.Message { 
    getId(): string;
    setId(value: string): InputsAddJob;
    getCallBackUrl(): string;
    setCallBackUrl(value: string): InputsAddJob;
    getAppPat(): string;
    setAppPat(value: string): InputsAddJob;

    hasProgress(): boolean;
    clearProgress(): void;
    getProgress(): InputsAddJobProgress | undefined;
    setProgress(value?: InputsAddJobProgress): InputsAddJob;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): InputsAddJob;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): InputsAddJob;
    clearExtractionJobsList(): void;
    getExtractionJobsList(): Array<InputsExtractionJob>;
    setExtractionJobsList(value: Array<InputsExtractionJob>): InputsAddJob;
    addExtractionJobs(value?: InputsExtractionJob, index?: number): InputsExtractionJob;
    clearUploadsList(): void;
    getUploadsList(): Array<Upload>;
    setUploadsList(value: Array<Upload>): InputsAddJob;
    addUploads(value?: Upload, index?: number): Upload;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): InputsAddJob;

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

export namespace InputsAddJob {
    export type AsObject = {
        id: 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,
    }
}

export class InputsAddJobProgress extends jspb.Message { 
    getPendingCount(): number;
    setPendingCount(value: number): InputsAddJobProgress;
    getInProgressCount(): number;
    setInProgressCount(value: number): InputsAddJobProgress;
    getSuccessCount(): number;
    setSuccessCount(value: number): InputsAddJobProgress;
    getFailedCount(): number;
    setFailedCount(value: number): InputsAddJobProgress;

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

export namespace InputsAddJobProgress {
    export type AsObject = {
        pendingCount: number,
        inProgressCount: number,
        successCount: number,
        failedCount: number,
    }
}

export class Upload extends jspb.Message { 
    getId(): string;
    setId(value: string): Upload;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Upload;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Upload;

    hasExpiresAt(): boolean;
    clearExpiresAt(): void;
    getExpiresAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setExpiresAt(value?: google_protobuf_timestamp_pb.Timestamp): Upload;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): Upload;
    getContentName(): string;
    setContentName(value: string): Upload;
    getContentLength(): number;
    setContentLength(value: number): Upload;
    getContentUrl(): string;
    setContentUrl(value: string): Upload;

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

export namespace Upload {
    export type AsObject = {
        id: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        expiresAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        contentName: string,
        contentLength: number,
        contentUrl: string,
    }
}

export class UploadContentPart extends jspb.Message { 
    getRangeStart(): number;
    setRangeStart(value: number): UploadContentPart;
    getPartNumber(): number;
    setPartNumber(value: number): UploadContentPart;
    getData(): Uint8Array | string;
    getData_asU8(): Uint8Array;
    getData_asB64(): string;
    setData(value: Uint8Array | string): UploadContentPart;

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

export namespace UploadContentPart {
    export type AsObject = {
        rangeStart: number,
        partNumber: number,
        data: Uint8Array | string,
    }
}

export class InputsExtractionJob extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): InputsExtractionJob;
    getId(): string;
    setId(value: string): InputsExtractionJob;
    getUrl(): string;
    setUrl(value: string): InputsExtractionJob;

    hasProgress(): boolean;
    clearProgress(): void;
    getProgress(): InputsExtractionJobProgress | undefined;
    setProgress(value?: InputsExtractionJobProgress): InputsExtractionJob;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): InputsExtractionJob;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): InputsExtractionJob;
    getInputIdConflictResolution(): InputIDConflictResolution;
    setInputIdConflictResolution(value: InputIDConflictResolution): InputsExtractionJob;

    hasInputTemplate(): boolean;
    clearInputTemplate(): void;
    getInputTemplate(): Input | undefined;
    setInputTemplate(value?: Input): InputsExtractionJob;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): InputsExtractionJob.AsObject;
    static toObject(includeInstance: boolean, msg: InputsExtractionJob): InputsExtractionJob.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
        inputTemplate?: Input.AsObject,
    }
}

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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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;

    hasUrl(): boolean;
    clearUrl(): void;
    getUrl(): DataSourceURL | undefined;
    setUrl(value?: DataSourceURL): InputsDataSource;
    getInputIdConflictResolution(): InputIDConflictResolution;
    setInputIdConflictResolution(value: InputIDConflictResolution): InputsDataSource;

    hasInputTemplate(): boolean;
    clearInputTemplate(): void;
    getInputTemplate(): Input | undefined;
    setInputTemplate(value?: Input): InputsDataSource;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): InputsDataSource.AsObject;
    static toObject(includeInstance: boolean, msg: InputsDataSource): InputsDataSource.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
        inputTemplate?: Input.AsObject,
    }
}

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

    hasCredentials(): boolean;
    clearCredentials(): void;
    getCredentials(): DataSourceCredentials | undefined;
    setCredentials(value?: DataSourceCredentials): DataSourceURL;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): DataSourceURL.AsObject;
    static toObject(includeInstance: boolean, msg: DataSourceURL): DataSourceURL.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 { 

    hasS3Creds(): boolean;
    clearS3Creds(): void;
    getS3Creds(): AWSCreds | undefined;
    setS3Creds(value?: AWSCreds): DataSourceCredentials;

    hasGcpCreds(): boolean;
    clearGcpCreds(): void;
    getGcpCreds(): Uint8Array | string;
    getGcpCreds_asU8(): Uint8Array;
    getGcpCreds_asB64(): string;
    setGcpCreds(value: Uint8Array | string): DataSourceCredentials;

    hasAzureBlobCreds(): boolean;
    clearAzureBlobCreds(): void;
    getAzureBlobCreds(): AzureBlobCreds | undefined;
    setAzureBlobCreds(value?: AzureBlobCreds): DataSourceCredentials;

    getCredentialsCase(): DataSourceCredentials.CredentialsCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): DataSourceCredentials.AsObject;
    static toObject(includeInstance: boolean, msg: DataSourceCredentials): DataSourceCredentials.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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;

    hasUpload(): boolean;
    clearUpload(): void;
    getUpload(): Upload | undefined;
    setUpload(value?: Upload): InputsUpload;
    getInputIdConflictResolution(): InputIDConflictResolution;
    setInputIdConflictResolution(value: InputIDConflictResolution): InputsUpload;

    hasInputTemplate(): boolean;
    clearInputTemplate(): void;
    getInputTemplate(): Input | undefined;
    setInputTemplate(value?: Input): InputsUpload;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): InputsUpload.AsObject;
    static toObject(includeInstance: boolean, msg: InputsUpload): InputsUpload.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
        inputTemplate?: Input.AsObject,
    }
}

export class BookmarkOrigin extends jspb.Message { 
    getId(): string;
    setId(value: string): BookmarkOrigin;
    getAppId(): string;
    setAppId(value: string): BookmarkOrigin;
    getUserId(): string;
    setUserId(value: string): BookmarkOrigin;
    getResourceType(): BookmarkOrigin.BookmarkType;
    setResourceType(value: BookmarkOrigin.BookmarkType): BookmarkOrigin;

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

export namespace BookmarkOrigin {
    export type AsObject = {
        id: string,
        appId: string,
        userId: string,
        resourceType: BookmarkOrigin.BookmarkType,
    }

    export enum BookmarkType {
    UNKNOWN = 0,
    MODEL = 1,
    WORKFLOW = 2,
    DATASET = 3,
    }

}

export class RunnerMetrics extends jspb.Message { 
    getPodsTotal(): number;
    setPodsTotal(value: number): RunnerMetrics;
    getPodsRunning(): number;
    setPodsRunning(value: number): RunnerMetrics;
    getTotalPodsRunningTimeS(): number;
    setTotalPodsRunningTimeS(value: number): RunnerMetrics;
    getPodsPreemptedTotal(): number;
    setPodsPreemptedTotal(value: number): RunnerMetrics;

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

export namespace RunnerMetrics {
    export type AsObject = {
        podsTotal: number,
        podsRunning: number,
        totalPodsRunningTimeS: number,
        podsPreemptedTotal: number,
    }
}

export class Runner extends jspb.Message { 
    getId(): string;
    setId(value: string): Runner;
    getDescription(): string;
    setDescription(value: string): Runner;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Runner;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Runner;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): Runner;
    clearLabelsList(): void;
    getLabelsList(): Array<string>;
    setLabelsList(value: Array<string>): Runner;
    addLabels(value: string, index?: number): string;

    hasWorker(): boolean;
    clearWorker(): void;
    getWorker(): Worker | undefined;
    setWorker(value?: Worker): Runner;

    hasNodepool(): boolean;
    clearNodepool(): void;
    getNodepool(): Nodepool | undefined;
    setNodepool(value?: Nodepool): Runner;

    hasComputeInfo(): boolean;
    clearComputeInfo(): void;
    getComputeInfo(): ComputeInfo | undefined;
    setComputeInfo(value?: ComputeInfo): Runner;
    getNumReplicas(): number;
    setNumReplicas(value: number): Runner;
    clearSpecialHandlingList(): void;
    getSpecialHandlingList(): Array<SpecialHandling>;
    setSpecialHandlingList(value: Array<SpecialHandling>): Runner;
    addSpecialHandling(value?: SpecialHandling, index?: number): SpecialHandling;

    hasRunnerMetrics(): boolean;
    clearRunnerMetrics(): void;
    getRunnerMetrics(): RunnerMetrics | undefined;
    setRunnerMetrics(value?: RunnerMetrics): Runner;
    getMinReplicas(): number;
    setMinReplicas(value: number): Runner;
    getPriority(): number;
    setPriority(value: number): Runner;

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

export namespace Runner {
    export type AsObject = {
        id: string,
        description: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        labelsList: Array<string>,
        worker?: Worker.AsObject,
        nodepool?: Nodepool.AsObject,
        computeInfo?: ComputeInfo.AsObject,
        numReplicas: number,
        specialHandlingList: Array<SpecialHandling.AsObject>,
        runnerMetrics?: RunnerMetrics.AsObject,
        minReplicas: number,
        priority: number,
    }
}

export class Nodepool extends jspb.Message { 
    getId(): string;
    setId(value: string): Nodepool;
    getDescription(): string;
    setDescription(value: string): Nodepool;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Nodepool;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Nodepool;

    hasComputeCluster(): boolean;
    clearComputeCluster(): void;
    getComputeCluster(): ComputeCluster | undefined;
    setComputeCluster(value?: ComputeCluster): Nodepool;

    hasNodeCapacityType(): boolean;
    clearNodeCapacityType(): void;
    getNodeCapacityType(): NodeCapacityType | undefined;
    setNodeCapacityType(value?: NodeCapacityType): Nodepool;
    clearInstanceTypesList(): void;
    getInstanceTypesList(): Array<InstanceType>;
    setInstanceTypesList(value: Array<InstanceType>): Nodepool;
    addInstanceTypes(value?: InstanceType, index?: number): InstanceType;
    getMinInstances(): number;
    setMinInstances(value: number): Nodepool;
    getMaxInstances(): number;
    setMaxInstances(value: number): Nodepool;
    getEnforcedMinInstances(): number;
    setEnforcedMinInstances(value: number): Nodepool;
    getEnforcedMaxInstances(): number;
    setEnforcedMaxInstances(value: number): Nodepool;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): Nodepool;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): Nodepool;
    clearSpecialHandlingList(): void;
    getSpecialHandlingList(): Array<SpecialHandling>;
    setSpecialHandlingList(value: Array<SpecialHandling>): Nodepool;
    addSpecialHandling(value?: SpecialHandling, index?: number): SpecialHandling;
    getNodeCount(): number;
    setNodeCount(value: number): Nodepool;
    getStatus(): Nodepool.NodepoolStatus;
    setStatus(value: Nodepool.NodepoolStatus): Nodepool;
    getStatusDescription(): string;
    setStatusDescription(value: string): Nodepool;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Nodepool.AsObject;
    static toObject(includeInstance: boolean, msg: Nodepool): Nodepool.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
        description: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        computeCluster?: ComputeCluster.AsObject,
        nodeCapacityType?: NodeCapacityType.AsObject,
        instanceTypesList: Array<InstanceType.AsObject>,
        minInstances: number,
        maxInstances: number,
        enforcedMinInstances: number,
        enforcedMaxInstances: number,
        visibility?: Visibility.AsObject,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        specialHandlingList: Array<SpecialHandling.AsObject>,
        nodeCount: number,
        status: Nodepool.NodepoolStatus,
        statusDescription: string,
    }

    export enum NodepoolStatus {
    NODEPOOL_STATUS_UNKNOWN = 0,
    NODEPOOL_STATUS_PENDING = 1,
    NODEPOOL_STATUS_READY = 2,
    NODEPOOL_STATUS_ERROR = 3,
    NODEPOOL_STATUS_DELETED = 4,
    }

}

export class NodeCapacityType extends jspb.Message { 
    clearCapacityTypesList(): void;
    getCapacityTypesList(): Array<NodeCapacityType.CapacityType>;
    setCapacityTypesList(value: Array<NodeCapacityType.CapacityType>): NodeCapacityType;
    addCapacityTypes(value: NodeCapacityType.CapacityType, index?: number): NodeCapacityType.CapacityType;

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

export namespace NodeCapacityType {
    export type AsObject = {
        capacityTypesList: Array<NodeCapacityType.CapacityType>,
    }

    export enum CapacityType {
    UKNOWN_CAPACITY_TYPE = 0,
    ON_DEMAND_TYPE = 1,
    SPOT_TYPE = 2,
    }

}

export class InstanceType extends jspb.Message { 
    getId(): string;
    setId(value: string): InstanceType;
    getDescription(): string;
    setDescription(value: string): InstanceType;

    hasComputeInfo(): boolean;
    clearComputeInfo(): void;
    getComputeInfo(): ComputeInfo | undefined;
    setComputeInfo(value?: ComputeInfo): InstanceType;
    getPrice(): string;
    setPrice(value: string): InstanceType;

    hasCloudProvider(): boolean;
    clearCloudProvider(): void;
    getCloudProvider(): CloudProvider | undefined;
    setCloudProvider(value?: CloudProvider): InstanceType;
    getRegion(): string;
    setRegion(value: string): InstanceType;

    hasAllowedCapacityTypes(): boolean;
    clearAllowedCapacityTypes(): void;
    getAllowedCapacityTypes(): NodeCapacityType | undefined;
    setAllowedCapacityTypes(value?: NodeCapacityType): InstanceType;
    getFeatureFlagGroup(): string;
    setFeatureFlagGroup(value: string): InstanceType;
    clearSpecialHandlingList(): void;
    getSpecialHandlingList(): Array<SpecialHandling>;
    setSpecialHandlingList(value: Array<SpecialHandling>): InstanceType;
    addSpecialHandling(value?: SpecialHandling, index?: number): SpecialHandling;
    getArchitecture(): string;
    setArchitecture(value: string): InstanceType;

    hasAvailableComputeInfo(): boolean;
    clearAvailableComputeInfo(): void;
    getAvailableComputeInfo(): ComputeInfo | undefined;
    setAvailableComputeInfo(value?: ComputeInfo): InstanceType;

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

export namespace InstanceType {
    export type AsObject = {
        id: string,
        description: string,
        computeInfo?: ComputeInfo.AsObject,
        price: string,
        cloudProvider?: CloudProvider.AsObject,
        region: string,
        allowedCapacityTypes?: NodeCapacityType.AsObject,
        featureFlagGroup: string,
        specialHandlingList: Array<SpecialHandling.AsObject>,
        architecture: string,
        availableComputeInfo?: ComputeInfo.AsObject,
    }
}

export class CloudProvider extends jspb.Message { 
    getId(): string;
    setId(value: string): CloudProvider;
    getName(): string;
    setName(value: string): CloudProvider;
    clearSpecialHandlingList(): void;
    getSpecialHandlingList(): Array<SpecialHandling>;
    setSpecialHandlingList(value: Array<SpecialHandling>): CloudProvider;
    addSpecialHandling(value?: SpecialHandling, index?: number): SpecialHandling;

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

export namespace CloudProvider {
    export type AsObject = {
        id: string,
        name: string,
        specialHandlingList: Array<SpecialHandling.AsObject>,
    }
}

export class CloudRegion extends jspb.Message { 
    getId(): string;
    setId(value: string): CloudRegion;
    clearSpecialHandlingList(): void;
    getSpecialHandlingList(): Array<SpecialHandling>;
    setSpecialHandlingList(value: Array<SpecialHandling>): CloudRegion;
    addSpecialHandling(value?: SpecialHandling, index?: number): SpecialHandling;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CloudRegion.AsObject;
    static toObject(includeInstance: boolean, msg: CloudRegion): CloudRegion.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
        specialHandlingList: Array<SpecialHandling.AsObject>,
    }
}

export class ComputeCluster extends jspb.Message { 
    getId(): string;
    setId(value: string): ComputeCluster;
    getDescription(): string;
    setDescription(value: string): ComputeCluster;

    hasCloudProvider(): boolean;
    clearCloudProvider(): void;
    getCloudProvider(): CloudProvider | undefined;
    setCloudProvider(value?: CloudProvider): ComputeCluster;
    getRegion(): string;
    setRegion(value: string): ComputeCluster;
    getUserId(): string;
    setUserId(value: string): ComputeCluster;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): ComputeCluster;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): ComputeCluster;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): ComputeCluster;
    getClusterType(): string;
    setClusterType(value: string): ComputeCluster;
    getManagedBy(): string;
    setManagedBy(value: string): ComputeCluster;

    hasKey(): boolean;
    clearKey(): void;
    getKey(): Key | undefined;
    setKey(value?: Key): ComputeCluster;

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

export namespace ComputeCluster {
    export type AsObject = {
        id: string,
        description: string,
        cloudProvider?: CloudProvider.AsObject,
        region: string,
        userId: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        visibility?: Visibility.AsObject,
        clusterType: string,
        managedBy: string,
        key?: Key.AsObject,
    }
}

export class ComputeInfo extends jspb.Message { 
    getCpuLimit(): string;
    setCpuLimit(value: string): ComputeInfo;
    getCpuMemory(): string;
    setCpuMemory(value: string): ComputeInfo;
    getCpuRequests(): string;
    setCpuRequests(value: string): ComputeInfo;
    getCpuMemoryRequests(): string;
    setCpuMemoryRequests(value: string): ComputeInfo;
    getNumAccelerators(): number;
    setNumAccelerators(value: number): ComputeInfo;
    getAcceleratorMemory(): string;
    setAcceleratorMemory(value: string): ComputeInfo;
    clearAcceleratorTypeList(): void;
    getAcceleratorTypeList(): Array<string>;
    setAcceleratorTypeList(value: Array<string>): ComputeInfo;
    addAcceleratorType(value: string, index?: number): string;
    clearAcceleratorTopologyList(): void;
    getAcceleratorTopologyList(): Array<string>;
    setAcceleratorTopologyList(value: Array<string>): ComputeInfo;
    addAcceleratorTopology(value: string, index?: number): string;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ComputeInfo.AsObject;
    static toObject(includeInstance: boolean, msg: ComputeInfo): ComputeInfo.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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 = {
        cpuLimit: string,
        cpuMemory: string,
        cpuRequests: string,
        cpuMemoryRequests: string,
        numAccelerators: number,
        acceleratorMemory: string,
        acceleratorTypeList: Array<string>,
        acceleratorTopologyList: 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;
    getDisablePacking(): boolean;
    setDisablePacking(value: boolean): AutoscaleConfig;
    getScaleToZeroDelaySeconds(): number;
    setScaleToZeroDelaySeconds(value: number): AutoscaleConfig;
    getSoftMinReplicas(): number;
    setSoftMinReplicas(value: number): AutoscaleConfig;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AutoscaleConfig.AsObject;
    static toObject(includeInstance: boolean, msg: AutoscaleConfig): AutoscaleConfig.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
        disablePacking: boolean,
        scaleToZeroDelaySeconds: number,
        softMinReplicas: number,
    }
}

export class DeploymentMetricsSummary extends jspb.Message { 
    getDesiredReplicas(): number;
    setDesiredReplicas(value: number): DeploymentMetricsSummary;
    getLiveReplicas(): number;
    setLiveReplicas(value: number): DeploymentMetricsSummary;
    getRolloutInProgress(): boolean;
    setRolloutInProgress(value: boolean): DeploymentMetricsSummary;

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

export namespace DeploymentMetricsSummary {
    export type AsObject = {
        desiredReplicas: number,
        liveReplicas: number,
        rolloutInProgress: boolean,
    }
}

export class NodepoolDeploymentMetrics extends jspb.Message { 
    getComputeClusterId(): string;
    setComputeClusterId(value: string): NodepoolDeploymentMetrics;
    getNodepoolId(): string;
    setNodepoolId(value: string): NodepoolDeploymentMetrics;

    hasMetrics(): boolean;
    clearMetrics(): void;
    getMetrics(): DeploymentMetricsSummary | undefined;
    setMetrics(value?: DeploymentMetricsSummary): NodepoolDeploymentMetrics;

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

export namespace NodepoolDeploymentMetrics {
    export type AsObject = {
        computeClusterId: string,
        nodepoolId: string,
        metrics?: DeploymentMetricsSummary.AsObject,
    }
}

export class DeploymentMetrics extends jspb.Message { 
    getDesiredReplicas(): number;
    setDesiredReplicas(value: number): DeploymentMetrics;
    getLiveReplicas(): number;
    setLiveReplicas(value: number): DeploymentMetrics;
    getRolloutInProgress(): boolean;
    setRolloutInProgress(value: boolean): DeploymentMetrics;
    clearNodepoolMetricsList(): void;
    getNodepoolMetricsList(): Array<NodepoolDeploymentMetrics>;
    setNodepoolMetricsList(value: Array<NodepoolDeploymentMetrics>): DeploymentMetrics;
    addNodepoolMetrics(value?: NodepoolDeploymentMetrics, index?: number): NodepoolDeploymentMetrics;

    hasAggregate(): boolean;
    clearAggregate(): void;
    getAggregate(): DeploymentMetricsSummary | undefined;
    setAggregate(value?: DeploymentMetricsSummary): DeploymentMetrics;

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

export namespace DeploymentMetrics {
    export type AsObject = {
        desiredReplicas: number,
        liveReplicas: number,
        rolloutInProgress: boolean,
        nodepoolMetricsList: Array<NodepoolDeploymentMetrics.AsObject>,
        aggregate?: DeploymentMetricsSummary.AsObject,
    }
}

export class Deployment extends jspb.Message { 
    getId(): string;
    setId(value: string): Deployment;
    getUserId(): string;
    setUserId(value: string): Deployment;

    hasAutoscaleConfig(): boolean;
    clearAutoscaleConfig(): void;
    getAutoscaleConfig(): AutoscaleConfig | undefined;
    setAutoscaleConfig(value?: AutoscaleConfig): Deployment;
    clearNodepoolsList(): void;
    getNodepoolsList(): Array<Nodepool>;
    setNodepoolsList(value: Array<Nodepool>): Deployment;
    addNodepools(value?: Nodepool, index?: number): Nodepool;
    getSchedulingChoice(): Deployment.SchedulingChoice;
    setSchedulingChoice(value: Deployment.SchedulingChoice): Deployment;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): Deployment;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): Deployment;
    getDescription(): string;
    setDescription(value: string): Deployment;

    hasWorker(): boolean;
    clearWorker(): void;
    getWorker(): Worker | undefined;
    setWorker(value?: Worker): Deployment;

    hasDesiredWorker(): boolean;
    clearDesiredWorker(): void;
    getDesiredWorker(): Worker | undefined;
    setDesiredWorker(value?: Worker): Deployment;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Deployment;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Deployment;
    getDeployLatestVersion(): boolean;
    setDeployLatestVersion(value: boolean): Deployment;
    clearSpecialHandlingList(): void;
    getSpecialHandlingList(): Array<SpecialHandling>;
    setSpecialHandlingList(value: Array<SpecialHandling>): Deployment;
    addSpecialHandling(value?: SpecialHandling, index?: number): SpecialHandling;

    hasEmailReminderAfter(): boolean;
    clearEmailReminderAfter(): void;
    getEmailReminderAfter(): google_protobuf_duration_pb.Duration | undefined;
    setEmailReminderAfter(value?: google_protobuf_duration_pb.Duration): Deployment;
    getGracefulDeploy(): boolean;
    setGracefulDeploy(value: boolean): Deployment;
    clearDeploymentNodepoolsList(): void;
    getDeploymentNodepoolsList(): Array<DeploymentNodepool>;
    setDeploymentNodepoolsList(value: Array<DeploymentNodepool>): Deployment;
    addDeploymentNodepools(value?: DeploymentNodepool, index?: number): DeploymentNodepool;

    hasDeploymentMetrics(): boolean;
    clearDeploymentMetrics(): void;
    getDeploymentMetrics(): DeploymentMetrics | undefined;
    setDeploymentMetrics(value?: DeploymentMetrics): Deployment;
    getStatus(): Deployment.Status;
    setStatus(value: Deployment.Status): Deployment;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Deployment.AsObject;
    static toObject(includeInstance: boolean, msg: Deployment): Deployment.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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>,
        schedulingChoice: Deployment.SchedulingChoice,
        visibility?: Visibility.AsObject,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        description: string,
        worker?: Worker.AsObject,
        desiredWorker?: Worker.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        deployLatestVersion: boolean,
        specialHandlingList: Array<SpecialHandling.AsObject>,
        emailReminderAfter?: google_protobuf_duration_pb.Duration.AsObject,
        gracefulDeploy: boolean,
        deploymentNodepoolsList: Array<DeploymentNodepool.AsObject>,
        deploymentMetrics?: DeploymentMetrics.AsObject,
        status: Deployment.Status,
    }

    export enum Status {
    ENABLED = 0,
    DISABLED = 1,
    }

    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 class DeploymentNodepool extends jspb.Message { 
    getId(): string;
    setId(value: string): DeploymentNodepool;

    hasComputeCluster(): boolean;
    clearComputeCluster(): void;
    getComputeCluster(): ComputeCluster | undefined;
    setComputeCluster(value?: ComputeCluster): DeploymentNodepool;
    getPriority(): number;
    setPriority(value: number): DeploymentNodepool;

    hasNodepool(): boolean;
    clearNodepool(): void;
    getNodepool(): Nodepool | undefined;
    setNodepool(value?: Nodepool): DeploymentNodepool;

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

export namespace DeploymentNodepool {
    export type AsObject = {
        id: string,
        computeCluster?: ComputeCluster.AsObject,
        priority: number,
        nodepool?: Nodepool.AsObject,
    }
}

export class RunnerSelector extends jspb.Message { 

    hasNodepool(): boolean;
    clearNodepool(): void;
    getNodepool(): Nodepool | undefined;
    setNodepool(value?: Nodepool): RunnerSelector;

    hasRunner(): boolean;
    clearRunner(): void;
    getRunner(): Runner | undefined;
    setRunner(value?: Runner): RunnerSelector;

    hasDeployment(): boolean;
    clearDeployment(): void;
    getDeployment(): Deployment | undefined;
    setDeployment(value?: Deployment): RunnerSelector;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): RunnerSelector.AsObject;
    static toObject(includeInstance: boolean, msg: RunnerSelector): RunnerSelector.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    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,
    }
}

export class ProcessingInfo extends jspb.Message { 
    getRunnerMethodType(): RunnerMethodType;
    setRunnerMethodType(value: RunnerMethodType): ProcessingInfo;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): ProcessingInfo;
    getProcessingId(): string;
    setProcessingId(value: string): ProcessingInfo;

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

export namespace ProcessingInfo {
    export type AsObject = {
        runnerMethodType: RunnerMethodType,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        processingId: string,
    }
}

export class AuditLogTarget extends jspb.Message { 

    hasUser(): boolean;
    clearUser(): void;
    getUser(): User | undefined;
    setUser(value?: User): AuditLogTarget;

    hasRole(): boolean;
    clearRole(): void;
    getRole(): Role | undefined;
    setRole(value?: Role): AuditLogTarget;

    hasTeam(): boolean;
    clearTeam(): void;
    getTeam(): Team | undefined;
    setTeam(value?: Team): AuditLogTarget;

    hasApp(): boolean;
    clearApp(): void;
    getApp(): App | undefined;
    setApp(value?: App): AuditLogTarget;

    hasWorkflow(): boolean;
    clearWorkflow(): void;
    getWorkflow(): Workflow | undefined;
    setWorkflow(value?: Workflow): AuditLogTarget;

    hasWorkflowVersion(): boolean;
    clearWorkflowVersion(): void;
    getWorkflowVersion(): WorkflowVersion | undefined;
    setWorkflowVersion(value?: WorkflowVersion): AuditLogTarget;

    hasModel(): boolean;
    clearModel(): void;
    getModel(): Model | undefined;
    setModel(value?: Model): AuditLogTarget;

    hasModelVersion(): boolean;
    clearModelVersion(): void;
    getModelVersion(): ModelVersion | undefined;
    setModelVersion(value?: ModelVersion): AuditLogTarget;

    hasComputeCluster(): boolean;
    clearComputeCluster(): void;
    getComputeCluster(): ComputeCluster | undefined;
    setComputeCluster(value?: ComputeCluster): AuditLogTarget;

    hasNodepool(): boolean;
    clearNodepool(): void;
    getNodepool(): Nodepool | undefined;
    setNodepool(value?: Nodepool): AuditLogTarget;

    hasDeployment(): boolean;
    clearDeployment(): void;
    getDeployment(): Deployment | undefined;
    setDeployment(value?: Deployment): AuditLogTarget;

    getTargetCase(): AuditLogTarget.TargetCase;

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

export namespace AuditLogTarget {
    export type AsObject = {
        user?: User.AsObject,
        role?: Role.AsObject,
        team?: Team.AsObject,
        app?: App.AsObject,
        workflow?: Workflow.AsObject,
        workflowVersion?: WorkflowVersion.AsObject,
        model?: Model.AsObject,
        modelVersion?: ModelVersion.AsObject,
        computeCluster?: ComputeCluster.AsObject,
        nodepool?: Nodepool.AsObject,
        deployment?: Deployment.AsObject,
    }

    export enum TargetCase {
        TARGET_NOT_SET = 0,
        USER = 1,
        ROLE = 2,
        TEAM = 3,
        APP = 4,
        WORKFLOW = 7,
        WORKFLOW_VERSION = 8,
        MODEL = 9,
        MODEL_VERSION = 10,
        COMPUTE_CLUSTER = 11,
        NODEPOOL = 12,
        DEPLOYMENT = 13,
    }

}

export class AuditLogEntry extends jspb.Message { 

    hasTimestamp(): boolean;
    clearTimestamp(): void;
    getTimestamp(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setTimestamp(value?: google_protobuf_timestamp_pb.Timestamp): AuditLogEntry;

    hasUser(): boolean;
    clearUser(): void;
    getUser(): User | undefined;
    setUser(value?: User): AuditLogEntry;
    getOperation(): EventType;
    setOperation(value: EventType): AuditLogEntry;
    getDescription(): string;
    setDescription(value: string): AuditLogEntry;
    clearTargetsList(): void;
    getTargetsList(): Array<AuditLogTarget>;
    setTargetsList(value: Array<AuditLogTarget>): AuditLogEntry;
    addTargets(value?: AuditLogTarget, index?: number): AuditLogTarget;
    clearDetailsList(): void;
    getDetailsList(): Array<string>;
    setDetailsList(value: Array<string>): AuditLogEntry;
    addDetails(value: string, index?: number): string;
    getSuccess(): boolean;
    setSuccess(value: boolean): AuditLogEntry;
    getReqId(): string;
    setReqId(value: string): AuditLogEntry;
    getSourceIp(): string;
    setSourceIp(value: string): AuditLogEntry;

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

export namespace AuditLogEntry {
    export type AsObject = {
        timestamp?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        user?: User.AsObject,
        operation: EventType,
        description: string,
        targetsList: Array<AuditLogTarget.AsObject>,
        detailsList: Array<string>,
        success: boolean,
        reqId: string,
        sourceIp: string,
    }
}

export class AuditLogQuery extends jspb.Message { 

    hasTimestampFrom(): boolean;
    clearTimestampFrom(): void;
    getTimestampFrom(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setTimestampFrom(value?: google_protobuf_timestamp_pb.Timestamp): AuditLogQuery;

    hasTimestampTo(): boolean;
    clearTimestampTo(): void;
    getTimestampTo(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setTimestampTo(value?: google_protobuf_timestamp_pb.Timestamp): AuditLogQuery;
    clearUserIdsList(): void;
    getUserIdsList(): Array<string>;
    setUserIdsList(value: Array<string>): AuditLogQuery;
    addUserIds(value: string, index?: number): string;
    clearOperationsList(): void;
    getOperationsList(): Array<EventType>;
    setOperationsList(value: Array<EventType>): AuditLogQuery;
    addOperations(value: EventType, index?: number): EventType;
    clearTargetsList(): void;
    getTargetsList(): Array<AuditLogTarget>;
    setTargetsList(value: Array<AuditLogTarget>): AuditLogQuery;
    addTargets(value?: AuditLogTarget, index?: number): AuditLogTarget;

    hasSuccess(): boolean;
    clearSuccess(): void;
    getSuccess(): google_protobuf_wrappers_pb.BoolValue | undefined;
    setSuccess(value?: google_protobuf_wrappers_pb.BoolValue): AuditLogQuery;
    clearSourceIpsList(): void;
    getSourceIpsList(): Array<string>;
    setSourceIpsList(value: Array<string>): AuditLogQuery;
    addSourceIps(value: string, index?: number): string;

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

export namespace AuditLogQuery {
    export type AsObject = {
        timestampFrom?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        timestampTo?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        userIdsList: Array<string>,
        operationsList: Array<EventType>,
        targetsList: Array<AuditLogTarget.AsObject>,
        success?: google_protobuf_wrappers_pb.BoolValue.AsObject,
        sourceIpsList: Array<string>,
    }
}

export class WorkflowVersionEvaluationMetric extends jspb.Message { 
    getId(): string;
    setId(value: string): WorkflowVersionEvaluationMetric;
    getSummary(): string;
    setSummary(value: string): WorkflowVersionEvaluationMetric;
    getDescription(): string;
    setDescription(value: string): WorkflowVersionEvaluationMetric;
    getDataType(): WorkflowVersionEvaluationMetric.DataType;
    setDataType(value: WorkflowVersionEvaluationMetric.DataType): WorkflowVersionEvaluationMetric;
    getVisualisationType(): WorkflowVersionEvaluationMetric.VisualisationType;
    setVisualisationType(value: WorkflowVersionEvaluationMetric.VisualisationType): WorkflowVersionEvaluationMetric;

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

export namespace WorkflowVersionEvaluationMetric {
    export type AsObject = {
        id: string,
        summary: string,
        description: string,
        dataType: WorkflowVersionEvaluationMetric.DataType,
        visualisationType: WorkflowVersionEvaluationMetric.VisualisationType,
    }

    export enum DataType {
    DATA_TYPE_NOT_SET = 0,
    FLOAT = 1,
    }

    export enum VisualisationType {
    VISUALIZATION_TYPE_NOT_SET = 0,
    CONFUSION_MATRIX = 1,
    PRECISION_RECALL_CURVE = 2,
    ROC_AUC_CURVE = 3,
    }

}

export class WorkflowVersionEvaluationTemplate extends jspb.Message { 
    getId(): string;
    setId(value: string): WorkflowVersionEvaluationTemplate;
    getDescription(): string;
    setDescription(value: string): WorkflowVersionEvaluationTemplate;
    clearTaskTypesList(): void;
    getTaskTypesList(): Array<WorkflowVersionEvaluationTemplate.TaskType>;
    setTaskTypesList(value: Array<WorkflowVersionEvaluationTemplate.TaskType>): WorkflowVersionEvaluationTemplate;
    addTaskTypes(value: WorkflowVersionEvaluationTemplate.TaskType, index?: number): WorkflowVersionEvaluationTemplate.TaskType;
    clearWorkflowVersionEvaluationMetricsList(): void;
    getWorkflowVersionEvaluationMetricsList(): Array<WorkflowVersionEvaluationMetric>;
    setWorkflowVersionEvaluationMetricsList(value: Array<WorkflowVersionEvaluationMetric>): WorkflowVersionEvaluationTemplate;
    addWorkflowVersionEvaluationMetrics(value?: WorkflowVersionEvaluationMetric, index?: number): WorkflowVersionEvaluationMetric;

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

export namespace WorkflowVersionEvaluationTemplate {
    export type AsObject = {
        id: string,
        description: string,
        taskTypesList: Array<WorkflowVersionEvaluationTemplate.TaskType>,
        workflowVersionEvaluationMetricsList: Array<WorkflowVersionEvaluationMetric.AsObject>,
    }

    export enum TaskType {
    TASK_TYPE_NOT_SET = 0,
    TEXT_CLASSIFICATION = 1,
    }

}

export class ComputePlaneMetrics extends jspb.Message { 

    hasMeta(): boolean;
    clearMeta(): void;
    getMeta(): ComputeSourceMetadata | undefined;
    setMeta(value?: ComputeSourceMetadata): ComputePlaneMetrics;
    getCloud(): string;
    setCloud(value: string): ComputePlaneMetrics;
    getRegion(): string;
    setRegion(value: string): ComputePlaneMetrics;
    getInstanceType(): string;
    setInstanceType(value: string): ComputePlaneMetrics;
    getReservationType(): string;
    setReservationType(value: string): ComputePlaneMetrics;
    getReservationPrice(): number;
    setReservationPrice(value: number): ComputePlaneMetrics;
    getRuntimeS(): number;
    setRuntimeS(value: number): ComputePlaneMetrics;

    hasTimestamp(): boolean;
    clearTimestamp(): void;
    getTimestamp(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setTimestamp(value?: google_protobuf_timestamp_pb.Timestamp): ComputePlaneMetrics;
    getEventType(): string;
    setEventType(value: string): ComputePlaneMetrics;
    clearGpuMetricsList(): void;
    getGpuMetricsList(): Array<GpuMetrics>;
    setGpuMetricsList(value: Array<GpuMetrics>): ComputePlaneMetrics;
    addGpuMetrics(value?: GpuMetrics, index?: number): GpuMetrics;
    getHostname(): string;
    setHostname(value: string): ComputePlaneMetrics;
    clearCpuMetricsList(): void;
    getCpuMetricsList(): Array<CpuMetrics>;
    setCpuMetricsList(value: Array<CpuMetrics>): ComputePlaneMetrics;
    addCpuMetrics(value?: CpuMetrics, index?: number): CpuMetrics;
    getIsFinalMetrics(): boolean;
    setIsFinalMetrics(value: boolean): ComputePlaneMetrics;

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

export namespace ComputePlaneMetrics {
    export type AsObject = {
        meta?: ComputeSourceMetadata.AsObject,
        cloud: string,
        region: string,
        instanceType: string,
        reservationType: string,
        reservationPrice: number,
        runtimeS: number,
        timestamp?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        eventType: string,
        gpuMetricsList: Array<GpuMetrics.AsObject>,
        hostname: string,
        cpuMetricsList: Array<CpuMetrics.AsObject>,
        isFinalMetrics: boolean,
    }
}

export class GpuMetrics extends jspb.Message { 
    getUuid(): string;
    setUuid(value: string): GpuMetrics;
    getModelName(): string;
    setModelName(value: string): GpuMetrics;
    getUtilizationPct(): number;
    setUtilizationPct(value: number): GpuMetrics;
    getTensorUtilizationPct(): number;
    setTensorUtilizationPct(value: number): GpuMetrics;
    getMemoryUtilizationPct(): number;
    setMemoryUtilizationPct(value: number): GpuMetrics;

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

export namespace GpuMetrics {
    export type AsObject = {
        uuid: string,
        modelName: string,
        utilizationPct: number,
        tensorUtilizationPct: number,
        memoryUtilizationPct: number,
    }
}

export class CpuMetrics extends jspb.Message { 

    hasTimestamp(): boolean;
    clearTimestamp(): void;
    getTimestamp(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setTimestamp(value?: google_protobuf_timestamp_pb.Timestamp): CpuMetrics;
    getCpuUtilizationPct(): number;
    setCpuUtilizationPct(value: number): CpuMetrics;
    getMemoryUtilizationPct(): number;
    setMemoryUtilizationPct(value: number): CpuMetrics;
    getMillicores(): number;
    setMillicores(value: number): CpuMetrics;
    getMemoryBytes(): number;
    setMemoryBytes(value: number): CpuMetrics;

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

export namespace CpuMetrics {
    export type AsObject = {
        timestamp?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        cpuUtilizationPct: number,
        memoryUtilizationPct: number,
        millicores: number,
        memoryBytes: number,
    }
}

export class RunnerReplicaTaskMetrics extends jspb.Message { 
    getTaskId(): string;
    setTaskId(value: string): RunnerReplicaTaskMetrics;

    hasStartTime(): boolean;
    clearStartTime(): void;
    getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): RunnerReplicaTaskMetrics;

    hasEndTime(): boolean;
    clearEndTime(): void;
    getEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setEndTime(value?: google_protobuf_timestamp_pb.Timestamp): RunnerReplicaTaskMetrics;

    hasStartFrameTime(): boolean;
    clearStartFrameTime(): void;
    getStartFrameTime(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setStartFrameTime(value?: google_protobuf_wrappers_pb.UInt64Value): RunnerReplicaTaskMetrics;

    hasEndFrameTime(): boolean;
    clearEndFrameTime(): void;
    getEndFrameTime(): google_protobuf_wrappers_pb.UInt64Value | undefined;
    setEndFrameTime(value?: google_protobuf_wrappers_pb.UInt64Value): RunnerReplicaTaskMetrics;
    getFramesProcessed(): number;
    setFramesProcessed(value: number): RunnerReplicaTaskMetrics;
    getFramesDropped(): number;
    setFramesDropped(value: number): RunnerReplicaTaskMetrics;
    getFramesSkipped(): number;
    setFramesSkipped(value: number): RunnerReplicaTaskMetrics;
    getAnnotationsUploaded(): number;
    setAnnotationsUploaded(value: number): RunnerReplicaTaskMetrics;
    getAnnotationsFailed(): number;
    setAnnotationsFailed(value: number): RunnerReplicaTaskMetrics;
    getBatchesUploaded(): number;
    setBatchesUploaded(value: number): RunnerReplicaTaskMetrics;
    getBatchesDropped(): number;
    setBatchesDropped(value: number): RunnerReplicaTaskMetrics;

    hasAvgUploadLatency(): boolean;
    clearAvgUploadLatency(): void;
    getAvgUploadLatency(): google_protobuf_duration_pb.Duration | undefined;
    setAvgUploadLatency(value?: google_protobuf_duration_pb.Duration): RunnerReplicaTaskMetrics;

    hasMaxUploadLatency(): boolean;
    clearMaxUploadLatency(): void;
    getMaxUploadLatency(): google_protobuf_duration_pb.Duration | undefined;
    setMaxUploadLatency(value?: google_protobuf_duration_pb.Duration): RunnerReplicaTaskMetrics;

    hasLastUploadLatency(): boolean;
    clearLastUploadLatency(): void;
    getLastUploadLatency(): google_protobuf_duration_pb.Duration | undefined;
    setLastUploadLatency(value?: google_protobuf_duration_pb.Duration): RunnerReplicaTaskMetrics;

    hasAvgStreamDelay(): boolean;
    clearAvgStreamDelay(): void;
    getAvgStreamDelay(): google_protobuf_duration_pb.Duration | undefined;
    setAvgStreamDelay(value?: google_protobuf_duration_pb.Duration): RunnerReplicaTaskMetrics;

    hasMaxStreamDelay(): boolean;
    clearMaxStreamDelay(): void;
    getMaxStreamDelay(): google_protobuf_duration_pb.Duration | undefined;
    setMaxStreamDelay(value?: google_protobuf_duration_pb.Duration): RunnerReplicaTaskMetrics;

    hasLastStreamDelay(): boolean;
    clearLastStreamDelay(): void;
    getLastStreamDelay(): google_protobuf_duration_pb.Duration | undefined;
    setLastStreamDelay(value?: google_protobuf_duration_pb.Duration): RunnerReplicaTaskMetrics;
    getPredictQueueSize(): number;
    setPredictQueueSize(value: number): RunnerReplicaTaskMetrics;
    getUploadQueueSize(): number;
    setUploadQueueSize(value: number): RunnerReplicaTaskMetrics;
    getCurrentFrameDropChance(): number;
    setCurrentFrameDropChance(value: number): RunnerReplicaTaskMetrics;

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

export namespace RunnerReplicaTaskMetrics {
    export type AsObject = {
        taskId: string,
        startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        startFrameTime?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        endFrameTime?: google_protobuf_wrappers_pb.UInt64Value.AsObject,
        framesProcessed: number,
        framesDropped: number,
        framesSkipped: number,
        annotationsUploaded: number,
        annotationsFailed: number,
        batchesUploaded: number,
        batchesDropped: number,
        avgUploadLatency?: google_protobuf_duration_pb.Duration.AsObject,
        maxUploadLatency?: google_protobuf_duration_pb.Duration.AsObject,
        lastUploadLatency?: google_protobuf_duration_pb.Duration.AsObject,
        avgStreamDelay?: google_protobuf_duration_pb.Duration.AsObject,
        maxStreamDelay?: google_protobuf_duration_pb.Duration.AsObject,
        lastStreamDelay?: google_protobuf_duration_pb.Duration.AsObject,
        predictQueueSize: number,
        uploadQueueSize: number,
        currentFrameDropChance: number,
    }
}

export class LogEntry extends jspb.Message { 
    getMessage(): string;
    setMessage(value: string): LogEntry;
    getLogType(): string;
    setLogType(value: string): LogEntry;
    getUrl(): string;
    setUrl(value: string): LogEntry;

    hasMeta(): boolean;
    clearMeta(): void;
    getMeta(): ComputeSourceMetadata | undefined;
    setMeta(value?: ComputeSourceMetadata): LogEntry;

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

export namespace LogEntry {
    export type AsObject = {
        message: string,
        logType: string,
        url: string,
        meta?: ComputeSourceMetadata.AsObject,
    }
}

export class ComputeSourceMetadata extends jspb.Message { 

    hasUserAppId(): boolean;
    clearUserAppId(): void;
    getUserAppId(): UserAppIDSet | undefined;
    setUserAppId(value?: UserAppIDSet): ComputeSourceMetadata;
    getModelId(): string;
    setModelId(value: string): ComputeSourceMetadata;
    getModelVersionId(): string;
    setModelVersionId(value: string): ComputeSourceMetadata;
    getWorkflowId(): string;
    setWorkflowId(value: string): ComputeSourceMetadata;
    getComputeClusterUserId(): string;
    setComputeClusterUserId(value: string): ComputeSourceMetadata;
    getComputeClusterId(): string;
    setComputeClusterId(value: string): ComputeSourceMetadata;
    getNodepoolId(): string;
    setNodepoolId(value: string): ComputeSourceMetadata;
    getRunnerId(): string;
    setRunnerId(value: string): ComputeSourceMetadata;
    getPipelineId(): string;
    setPipelineId(value: string): ComputeSourceMetadata;
    getPipelineVersionId(): string;
    setPipelineVersionId(value: string): ComputeSourceMetadata;
    getPipelineVersionRunId(): string;
    setPipelineVersionRunId(value: string): ComputeSourceMetadata;
    getPipelineStepId(): string;
    setPipelineStepId(value: string): ComputeSourceMetadata;
    getPipelineStepVersionId(): string;
    setPipelineStepVersionId(value: string): ComputeSourceMetadata;

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

export namespace ComputeSourceMetadata {
    export type AsObject = {
        userAppId?: UserAppIDSet.AsObject,
        modelId: string,
        modelVersionId: string,
        workflowId: string,
        computeClusterUserId: string,
        computeClusterId: string,
        nodepoolId: string,
        runnerId: string,
        pipelineId: string,
        pipelineVersionId: string,
        pipelineVersionRunId: string,
        pipelineStepId: string,
        pipelineStepVersionId: string,
    }
}

export class WorkflowVersionEvaluation extends jspb.Message { 
    getId(): string;
    setId(value: string): WorkflowVersionEvaluation;

    hasWorkflowVersion(): boolean;
    clearWorkflowVersion(): void;
    getWorkflowVersion(): WorkflowVersion | undefined;
    setWorkflowVersion(value?: WorkflowVersion): WorkflowVersionEvaluation;
    getTargetNodeId(): string;
    setTargetNodeId(value: string): WorkflowVersionEvaluation;

    hasGroundTruthDatasetVersion(): boolean;
    clearGroundTruthDatasetVersion(): void;
    getGroundTruthDatasetVersion(): DatasetVersion | undefined;
    setGroundTruthDatasetVersion(value?: DatasetVersion): WorkflowVersionEvaluation;

    hasPredictionsDatasetVersion(): boolean;
    clearPredictionsDatasetVersion(): void;
    getPredictionsDatasetVersion(): DatasetVersion | undefined;
    setPredictionsDatasetVersion(value?: DatasetVersion): WorkflowVersionEvaluation;

    hasWorkflowVersionEvaluationTemplate(): boolean;
    clearWorkflowVersionEvaluationTemplate(): void;
    getWorkflowVersionEvaluationTemplate(): WorkflowVersionEvaluationTemplate | undefined;
    setWorkflowVersionEvaluationTemplate(value?: WorkflowVersionEvaluationTemplate): WorkflowVersionEvaluation;
    getUserId(): string;
    setUserId(value: string): WorkflowVersionEvaluation;
    getAppId(): string;
    setAppId(value: string): WorkflowVersionEvaluation;

    hasWorkflowEvaluationResult(): boolean;
    clearWorkflowEvaluationResult(): void;
    getWorkflowEvaluationResult(): WorkflowEvaluationResult | undefined;
    setWorkflowEvaluationResult(value?: WorkflowEvaluationResult): WorkflowVersionEvaluation;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): WorkflowVersionEvaluation;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): WorkflowVersionEvaluation;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): WorkflowVersionEvaluation;

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

export namespace WorkflowVersionEvaluation {
    export type AsObject = {
        id: string,
        workflowVersion?: WorkflowVersion.AsObject,
        targetNodeId: string,
        groundTruthDatasetVersion?: DatasetVersion.AsObject,
        predictionsDatasetVersion?: DatasetVersion.AsObject,
        workflowVersionEvaluationTemplate?: WorkflowVersionEvaluationTemplate.AsObject,
        userId: string,
        appId: string,
        workflowEvaluationResult?: WorkflowEvaluationResult.AsObject,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class WorkflowEvaluationResult extends jspb.Message { 

    hasSummary(): boolean;
    clearSummary(): void;
    getSummary(): WorkflowEvaluationResultSummary | undefined;
    setSummary(value?: WorkflowEvaluationResultSummary): WorkflowEvaluationResult;

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

export namespace WorkflowEvaluationResult {
    export type AsObject = {
        summary?: WorkflowEvaluationResultSummary.AsObject,
    }
}

export class WorkflowEvaluationResultSummary extends jspb.Message { 
    clearEvaluationMetricValuesList(): void;
    getEvaluationMetricValuesList(): Array<EvaluationMetricValue>;
    setEvaluationMetricValuesList(value: Array<EvaluationMetricValue>): WorkflowEvaluationResultSummary;
    addEvaluationMetricValues(value?: EvaluationMetricValue, index?: number): EvaluationMetricValue;

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

export namespace WorkflowEvaluationResultSummary {
    export type AsObject = {
        evaluationMetricValuesList: Array<EvaluationMetricValue.AsObject>,
    }
}

export class EvaluationMetricValue extends jspb.Message { 
    getEvaluationMetricId(): string;
    setEvaluationMetricId(value: string): EvaluationMetricValue;

    hasMetricValue(): boolean;
    clearMetricValue(): void;
    getMetricValue(): MetricValue | undefined;
    setMetricValue(value?: MetricValue): EvaluationMetricValue;
    getExplanation(): string;
    setExplanation(value: string): EvaluationMetricValue;

    getPerConceptValuesMap(): jspb.Map<string, MetricValue>;
    clearPerConceptValuesMap(): void;

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

export namespace EvaluationMetricValue {
    export type AsObject = {
        evaluationMetricId: string,
        metricValue?: MetricValue.AsObject,
        explanation: string,

        perConceptValuesMap: Array<[string, MetricValue.AsObject]>,
    }
}

export class InputEvaluationMetricValue extends jspb.Message { 
    getEvaluationMetricId(): string;
    setEvaluationMetricId(value: string): InputEvaluationMetricValue;

    hasMetricValue(): boolean;
    clearMetricValue(): void;
    getMetricValue(): MetricValue | undefined;
    setMetricValue(value?: MetricValue): InputEvaluationMetricValue;
    getExplanation(): string;
    setExplanation(value: string): InputEvaluationMetricValue;

    getPerRegionValuesMap(): jspb.Map<string, MetricValue>;
    clearPerRegionValuesMap(): void;

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

export namespace InputEvaluationMetricValue {
    export type AsObject = {
        evaluationMetricId: string,
        metricValue?: MetricValue.AsObject,
        explanation: string,

        perRegionValuesMap: Array<[string, MetricValue.AsObject]>,
    }
}

export class MetricValue extends jspb.Message { 

    hasStringValue(): boolean;
    clearStringValue(): void;
    getStringValue(): string;
    setStringValue(value: string): MetricValue;

    hasFloatValue(): boolean;
    clearFloatValue(): void;
    getFloatValue(): number;
    setFloatValue(value: number): MetricValue;

    hasIntValue(): boolean;
    clearIntValue(): void;
    getIntValue(): number;
    setIntValue(value: number): MetricValue;

    getMetricValueCase(): MetricValue.MetricValueCase;

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

export namespace MetricValue {
    export type AsObject = {
        stringValue: string,
        floatValue: number,
        intValue: number,
    }

    export enum MetricValueCase {
        METRIC_VALUE_NOT_SET = 0,
        STRING_VALUE = 1,
        FLOAT_VALUE = 2,
        INT_VALUE = 3,
    }

}

export class WorkflowEvaluationInputResult extends jspb.Message { 
    clearInputEvaluationMetricValuesList(): void;
    getInputEvaluationMetricValuesList(): Array<InputEvaluationMetricValue>;
    setInputEvaluationMetricValuesList(value: Array<InputEvaluationMetricValue>): WorkflowEvaluationInputResult;
    addInputEvaluationMetricValues(value?: InputEvaluationMetricValue, index?: number): InputEvaluationMetricValue;

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

export namespace WorkflowEvaluationInputResult {
    export type AsObject = {
        inputEvaluationMetricValuesList: Array<InputEvaluationMetricValue.AsObject>,
    }
}

export class WorkflowVersionEvaluationData extends jspb.Message { 
    getId(): string;
    setId(value: string): WorkflowVersionEvaluationData;

    hasInput(): boolean;
    clearInput(): void;
    getInput(): Input | undefined;
    setInput(value?: Input): WorkflowVersionEvaluationData;
    clearGroundTruthsList(): void;
    getGroundTruthsList(): Array<Data>;
    setGroundTruthsList(value: Array<Data>): WorkflowVersionEvaluationData;
    addGroundTruths(value?: Data, index?: number): Data;
    clearPredictionsList(): void;
    getPredictionsList(): Array<Data>;
    setPredictionsList(value: Array<Data>): WorkflowVersionEvaluationData;
    addPredictions(value?: Data, index?: number): Data;

    hasWorkflowEvaluationSampleResult(): boolean;
    clearWorkflowEvaluationSampleResult(): void;
    getWorkflowEvaluationSampleResult(): WorkflowEvaluationInputResult | undefined;
    setWorkflowEvaluationSampleResult(value?: WorkflowEvaluationInputResult): WorkflowVersionEvaluationData;

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

export namespace WorkflowVersionEvaluationData {
    export type AsObject = {
        id: string,
        input?: Input.AsObject,
        groundTruthsList: Array<Data.AsObject>,
        predictionsList: Array<Data.AsObject>,
        workflowEvaluationSampleResult?: WorkflowEvaluationInputResult.AsObject,
    }
}

export class ArgoParameterOverride extends jspb.Message { 
    getName(): string;
    setName(value: string): ArgoParameterOverride;
    getValue(): string;
    setValue(value: string): ArgoParameterOverride;

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

export namespace ArgoParameterOverride {
    export type AsObject = {
        name: string,
        value: string,
    }
}

export class ArgoArgsOverride extends jspb.Message { 
    clearParametersList(): void;
    getParametersList(): Array<ArgoParameterOverride>;
    setParametersList(value: Array<ArgoParameterOverride>): ArgoArgsOverride;
    addParameters(value?: ArgoParameterOverride, index?: number): ArgoParameterOverride;

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

export namespace ArgoArgsOverride {
    export type AsObject = {
        parametersList: Array<ArgoParameterOverride.AsObject>,
    }
}

export class OrchestrationArgsOverride extends jspb.Message { 

    hasArgoArgsOverride(): boolean;
    clearArgoArgsOverride(): void;
    getArgoArgsOverride(): ArgoArgsOverride | undefined;
    setArgoArgsOverride(value?: ArgoArgsOverride): OrchestrationArgsOverride;

    getOverrideCase(): OrchestrationArgsOverride.OverrideCase;

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

export namespace OrchestrationArgsOverride {
    export type AsObject = {
        argoArgsOverride?: ArgoArgsOverride.AsObject,
    }

    export enum OverrideCase {
        OVERRIDE_NOT_SET = 0,
        ARGO_ARGS_OVERRIDE = 1,
    }

}

export class ArgoOrchestrationSpec extends jspb.Message { 
    getApiVersion(): string;
    setApiVersion(value: string): ArgoOrchestrationSpec;
    getSpecJson(): string;
    setSpecJson(value: string): ArgoOrchestrationSpec;

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

export namespace ArgoOrchestrationSpec {
    export type AsObject = {
        apiVersion: string,
        specJson: string,
    }
}

export class OrchestrationSpec extends jspb.Message { 

    hasArgoOrchestrationSpec(): boolean;
    clearArgoOrchestrationSpec(): void;
    getArgoOrchestrationSpec(): ArgoOrchestrationSpec | undefined;
    setArgoOrchestrationSpec(value?: ArgoOrchestrationSpec): OrchestrationSpec;

    getOrchestrationCase(): OrchestrationSpec.OrchestrationCase;

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

export namespace OrchestrationSpec {
    export type AsObject = {
        argoOrchestrationSpec?: ArgoOrchestrationSpec.AsObject,
    }

    export enum OrchestrationCase {
        ORCHESTRATION_NOT_SET = 0,
        ARGO_ORCHESTRATION_SPEC = 1,
    }

}

export class PipelineStepInputParam extends jspb.Message { 
    getName(): string;
    setName(value: string): PipelineStepInputParam;
    getDefaultValue(): string;
    setDefaultValue(value: string): PipelineStepInputParam;
    getDescription(): string;
    setDescription(value: string): PipelineStepInputParam;
    clearAcceptedValuesList(): void;
    getAcceptedValuesList(): Array<string>;
    setAcceptedValuesList(value: Array<string>): PipelineStepInputParam;
    addAcceptedValues(value: string, index?: number): string;

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

export namespace PipelineStepInputParam {
    export type AsObject = {
        name: string,
        defaultValue: string,
        description: string,
        acceptedValuesList: Array<string>,
    }
}

export class PipelineStep extends jspb.Message { 
    getId(): string;
    setId(value: string): PipelineStep;
    getUserId(): string;
    setUserId(value: string): PipelineStep;
    getDescription(): string;
    setDescription(value: string): PipelineStep;

    hasPipelineStepVersion(): boolean;
    clearPipelineStepVersion(): void;
    getPipelineStepVersion(): PipelineStepVersion | undefined;
    setPipelineStepVersion(value?: PipelineStepVersion): PipelineStep;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): PipelineStep;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): PipelineStep;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): PipelineStep;

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

export namespace PipelineStep {
    export type AsObject = {
        id: string,
        userId: string,
        description: string,
        pipelineStepVersion?: PipelineStepVersion.AsObject,
        visibility?: Visibility.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class OrchestrationStepSpec extends jspb.Message { 

    hasArgoOrchestrationStepSpec(): boolean;
    clearArgoOrchestrationStepSpec(): void;
    getArgoOrchestrationStepSpec(): ArgoOrchestrationStepSpec | undefined;
    setArgoOrchestrationStepSpec(value?: ArgoOrchestrationStepSpec): OrchestrationStepSpec;

    getOrchestrationCase(): OrchestrationStepSpec.OrchestrationCase;

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

export namespace OrchestrationStepSpec {
    export type AsObject = {
        argoOrchestrationStepSpec?: ArgoOrchestrationStepSpec.AsObject,
    }

    export enum OrchestrationCase {
        ORCHESTRATION_NOT_SET = 0,
        ARGO_ORCHESTRATION_STEP_SPEC = 1,
    }

}

export class ArgoOrchestrationStepSpec extends jspb.Message { 
    getApiVersion(): string;
    setApiVersion(value: string): ArgoOrchestrationStepSpec;
    getSpecJson(): string;
    setSpecJson(value: string): ArgoOrchestrationStepSpec;

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

export namespace ArgoOrchestrationStepSpec {
    export type AsObject = {
        apiVersion: string,
        specJson: string,
    }
}

export class PipelineStepVersion extends jspb.Message { 
    getId(): string;
    setId(value: string): PipelineStepVersion;
    getUserId(): string;
    setUserId(value: string): PipelineStepVersion;
    getAppId(): string;
    setAppId(value: string): PipelineStepVersion;
    getDescription(): string;
    setDescription(value: string): PipelineStepVersion;

    hasPipelineStep(): boolean;
    clearPipelineStep(): void;
    getPipelineStep(): PipelineStep | undefined;
    setPipelineStep(value?: PipelineStep): PipelineStepVersion;

    hasOrchestrationStepSpec(): boolean;
    clearOrchestrationStepSpec(): void;
    getOrchestrationStepSpec(): OrchestrationStepSpec | undefined;
    setOrchestrationStepSpec(value?: OrchestrationStepSpec): PipelineStepVersion;
    clearPipelineStepInputParamsList(): void;
    getPipelineStepInputParamsList(): Array<PipelineStepInputParam>;
    setPipelineStepInputParamsList(value: Array<PipelineStepInputParam>): PipelineStepVersion;
    addPipelineStepInputParams(value?: PipelineStepInputParam, index?: number): PipelineStepInputParam;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): PipelineStepVersion;

    hasPipelineStepComputeInfo(): boolean;
    clearPipelineStepComputeInfo(): void;
    getPipelineStepComputeInfo(): ComputeInfo | undefined;
    setPipelineStepComputeInfo(value?: ComputeInfo): PipelineStepVersion;

    hasBuildInfo(): boolean;
    clearBuildInfo(): void;
    getBuildInfo(): BuildInfo | undefined;
    setBuildInfo(value?: BuildInfo): PipelineStepVersion;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): PipelineStepVersion;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): PipelineStepVersion;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): PipelineStepVersion;

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

export namespace PipelineStepVersion {
    export type AsObject = {
        id: string,
        userId: string,
        appId: string,
        description: string,
        pipelineStep?: PipelineStep.AsObject,
        orchestrationStepSpec?: OrchestrationStepSpec.AsObject,
        pipelineStepInputParamsList: Array<PipelineStepInputParam.AsObject>,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        pipelineStepComputeInfo?: ComputeInfo.AsObject,
        buildInfo?: BuildInfo.AsObject,
        visibility?: Visibility.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class Pipeline extends jspb.Message { 
    getId(): string;
    setId(value: string): Pipeline;
    getUserId(): string;
    setUserId(value: string): Pipeline;
    getAppId(): string;
    setAppId(value: string): Pipeline;

    hasPipelineVersion(): boolean;
    clearPipelineVersion(): void;
    getPipelineVersion(): PipelineVersion | undefined;
    setPipelineVersion(value?: PipelineVersion): Pipeline;
    getDescription(): string;
    setDescription(value: string): Pipeline;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): Pipeline;
    getNotes(): string;
    setNotes(value: string): Pipeline;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): Pipeline;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Pipeline;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Pipeline;

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

export namespace Pipeline {
    export type AsObject = {
        id: string,
        userId: string,
        appId: string,
        pipelineVersion?: PipelineVersion.AsObject,
        description: string,
        visibility?: Visibility.AsObject,
        notes: string,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class PipelineVersionConfig extends jspb.Message { 

    getStepVersionSecretsMap(): jspb.Map<string, google_protobuf_struct_pb.Struct>;
    clearStepVersionSecretsMap(): void;

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

export namespace PipelineVersionConfig {
    export type AsObject = {

        stepVersionSecretsMap: Array<[string, google_protobuf_struct_pb.Struct.AsObject]>,
    }
}

export class PipelineVersion extends jspb.Message { 
    getId(): string;
    setId(value: string): PipelineVersion;
    getAppId(): string;
    setAppId(value: string): PipelineVersion;
    getUserId(): string;
    setUserId(value: string): PipelineVersion;

    hasOrchestrationSpec(): boolean;
    clearOrchestrationSpec(): void;
    getOrchestrationSpec(): OrchestrationSpec | undefined;
    setOrchestrationSpec(value?: OrchestrationSpec): PipelineVersion;
    getPipelineId(): string;
    setPipelineId(value: string): PipelineVersion;
    getDescription(): string;
    setDescription(value: string): PipelineVersion;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): PipelineVersion;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): google_protobuf_struct_pb.Struct | undefined;
    setMetadata(value?: google_protobuf_struct_pb.Struct): PipelineVersion;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): PipelineVersion;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): PipelineVersion;

    hasConfig(): boolean;
    clearConfig(): void;
    getConfig(): PipelineVersionConfig | undefined;
    setConfig(value?: PipelineVersionConfig): PipelineVersion;

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

export namespace PipelineVersion {
    export type AsObject = {
        id: string,
        appId: string,
        userId: string,
        orchestrationSpec?: OrchestrationSpec.AsObject,
        pipelineId: string,
        description: string,
        visibility?: Visibility.AsObject,
        metadata?: google_protobuf_struct_pb.Struct.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        config?: PipelineVersionConfig.AsObject,
    }
}

export class OrchestrationStatus extends jspb.Message { 

    hasArgoStatus(): boolean;
    clearArgoStatus(): void;
    getArgoStatus(): ArgoOrchestrationStatus | undefined;
    setArgoStatus(value?: ArgoOrchestrationStatus): OrchestrationStatus;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): OrchestrationStatus;

    getStatusDetailsCase(): OrchestrationStatus.StatusDetailsCase;

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

export namespace OrchestrationStatus {
    export type AsObject = {
        argoStatus?: ArgoOrchestrationStatus.AsObject,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
    }

    export enum StatusDetailsCase {
        STATUS_DETAILS_NOT_SET = 0,
        ARGO_STATUS = 1,
    }

}

export class ArgoOrchestrationStatus extends jspb.Message { 
    getStatus(): string;
    setStatus(value: string): ArgoOrchestrationStatus;

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

export namespace ArgoOrchestrationStatus {
    export type AsObject = {
        status: string,
    }
}

export class PipelineVersionRun extends jspb.Message { 
    getId(): string;
    setId(value: string): PipelineVersionRun;

    hasPipelineVersion(): boolean;
    clearPipelineVersion(): void;
    getPipelineVersion(): PipelineVersion | undefined;
    setPipelineVersion(value?: PipelineVersion): PipelineVersionRun;
    clearNodepoolsList(): void;
    getNodepoolsList(): Array<Nodepool>;
    setNodepoolsList(value: Array<Nodepool>): PipelineVersionRun;
    addNodepools(value?: Nodepool, index?: number): Nodepool;

    hasOrchestrationStatus(): boolean;
    clearOrchestrationStatus(): void;
    getOrchestrationStatus(): OrchestrationStatus | undefined;
    setOrchestrationStatus(value?: OrchestrationStatus): PipelineVersionRun;
    getUserId(): string;
    setUserId(value: string): PipelineVersionRun;
    getAppId(): string;
    setAppId(value: string): PipelineVersionRun;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): PipelineVersionRun;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): PipelineVersionRun;

    hasInputArgsOverride(): boolean;
    clearInputArgsOverride(): void;
    getInputArgsOverride(): OrchestrationArgsOverride | undefined;
    setInputArgsOverride(value?: OrchestrationArgsOverride): PipelineVersionRun;

    hasOrchestrationSpec(): boolean;
    clearOrchestrationSpec(): void;
    getOrchestrationSpec(): OrchestrationSpec | undefined;
    setOrchestrationSpec(value?: OrchestrationSpec): PipelineVersionRun;

    hasStartedAt(): boolean;
    clearStartedAt(): void;
    getStartedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setStartedAt(value?: google_protobuf_timestamp_pb.Timestamp): PipelineVersionRun;

    hasEndedAt(): boolean;
    clearEndedAt(): void;
    getEndedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setEndedAt(value?: google_protobuf_timestamp_pb.Timestamp): PipelineVersionRun;

    hasTotalRunDuration(): boolean;
    clearTotalRunDuration(): void;
    getTotalRunDuration(): google_protobuf_duration_pb.Duration | undefined;
    setTotalRunDuration(value?: google_protobuf_duration_pb.Duration): PipelineVersionRun;

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

export namespace PipelineVersionRun {
    export type AsObject = {
        id: string,
        pipelineVersion?: PipelineVersion.AsObject,
        nodepoolsList: Array<Nodepool.AsObject>,
        orchestrationStatus?: OrchestrationStatus.AsObject,
        userId: string,
        appId: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        inputArgsOverride?: OrchestrationArgsOverride.AsObject,
        orchestrationSpec?: OrchestrationSpec.AsObject,
        startedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        endedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        totalRunDuration?: google_protobuf_duration_pb.Duration.AsObject,
    }
}

export class PipelineVersionRunStatusLog extends jspb.Message { 
    getId(): string;
    setId(value: string): PipelineVersionRunStatusLog;
    getPipelineVersionRunId(): string;
    setPipelineVersionRunId(value: string): PipelineVersionRunStatusLog;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): proto_clarifai_api_status_status_pb.Status | undefined;
    setStatus(value?: proto_clarifai_api_status_status_pb.Status): PipelineVersionRunStatusLog;
    getMessage(): string;
    setMessage(value: string): PipelineVersionRunStatusLog;
    getTriggeredByUserId(): string;
    setTriggeredByUserId(value: string): PipelineVersionRunStatusLog;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): PipelineVersionRunStatusLog;

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

export namespace PipelineVersionRunStatusLog {
    export type AsObject = {
        id: string,
        pipelineVersionRunId: string,
        status?: proto_clarifai_api_status_status_pb.Status.AsObject,
        message: string,
        triggeredByUserId: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class PipelineTemplateParameter extends jspb.Message { 
    getName(): string;
    setName(value: string): PipelineTemplateParameter;
    getType(): PipelineTemplateParameter.Type;
    setType(value: PipelineTemplateParameter.Type): PipelineTemplateParameter;
    getRequired(): boolean;
    setRequired(value: boolean): PipelineTemplateParameter;

    hasDefaultString(): boolean;
    clearDefaultString(): void;
    getDefaultString(): string;
    setDefaultString(value: string): PipelineTemplateParameter;

    hasDefaultInt(): boolean;
    clearDefaultInt(): void;
    getDefaultInt(): number;
    setDefaultInt(value: number): PipelineTemplateParameter;

    hasDefaultFloat(): boolean;
    clearDefaultFloat(): void;
    getDefaultFloat(): number;
    setDefaultFloat(value: number): PipelineTemplateParameter;

    hasDefaultBool(): boolean;
    clearDefaultBool(): void;
    getDefaultBool(): boolean;
    setDefaultBool(value: boolean): PipelineTemplateParameter;
    getDescription(): string;
    setDescription(value: string): PipelineTemplateParameter;

    hasConstraints(): boolean;
    clearConstraints(): void;
    getConstraints(): PipelineTemplateParameter.Constraints | undefined;
    setConstraints(value?: PipelineTemplateParameter.Constraints): PipelineTemplateParameter;

    hasUiHints(): boolean;
    clearUiHints(): void;
    getUiHints(): PipelineTemplateParameter.UIHints | undefined;
    setUiHints(value?: PipelineTemplateParameter.UIHints): PipelineTemplateParameter;

    getDefaultValueCase(): PipelineTemplateParameter.DefaultValueCase;

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

export namespace PipelineTemplateParameter {
    export type AsObject = {
        name: string,
        type: PipelineTemplateParameter.Type,
        required: boolean,
        defaultString: string,
        defaultInt: number,
        defaultFloat: number,
        defaultBool: boolean,
        description: string,
        constraints?: PipelineTemplateParameter.Constraints.AsObject,
        uiHints?: PipelineTemplateParameter.UIHints.AsObject,
    }


    export class Constraints extends jspb.Message { 

        hasStringConstraints(): boolean;
        clearStringConstraints(): void;
        getStringConstraints(): PipelineTemplateParameter.Constraints.StringConstraints | undefined;
        setStringConstraints(value?: PipelineTemplateParameter.Constraints.StringConstraints): Constraints;

        hasIntConstraints(): boolean;
        clearIntConstraints(): void;
        getIntConstraints(): PipelineTemplateParameter.Constraints.IntConstraints | undefined;
        setIntConstraints(value?: PipelineTemplateParameter.Constraints.IntConstraints): Constraints;

        hasFloatConstraints(): boolean;
        clearFloatConstraints(): void;
        getFloatConstraints(): PipelineTemplateParameter.Constraints.FloatConstraints | undefined;
        setFloatConstraints(value?: PipelineTemplateParameter.Constraints.FloatConstraints): Constraints;

        getConstraintsCase(): Constraints.ConstraintsCase;

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

    export namespace Constraints {
        export type AsObject = {
            stringConstraints?: PipelineTemplateParameter.Constraints.StringConstraints.AsObject,
            intConstraints?: PipelineTemplateParameter.Constraints.IntConstraints.AsObject,
            floatConstraints?: PipelineTemplateParameter.Constraints.FloatConstraints.AsObject,
        }


        export class StringConstraints extends jspb.Message { 
            clearAllowedValuesList(): void;
            getAllowedValuesList(): Array<string>;
            setAllowedValuesList(value: Array<string>): StringConstraints;
            addAllowedValues(value: string, index?: number): string;
            getAllowFreeText(): boolean;
            setAllowFreeText(value: boolean): StringConstraints;
            getMinLength(): number;
            setMinLength(value: number): StringConstraints;
            getMaxLength(): number;
            setMaxLength(value: number): StringConstraints;

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

        export namespace StringConstraints {
            export type AsObject = {
                allowedValuesList: Array<string>,
                allowFreeText: boolean,
                minLength: number,
                maxLength: number,
            }
        }

        export class IntConstraints extends jspb.Message { 
            getMin(): number;
            setMin(value: number): IntConstraints;
            getMax(): number;
            setMax(value: number): IntConstraints;

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

        export namespace IntConstraints {
            export type AsObject = {
                min: number,
                max: number,
            }
        }

        export class FloatConstraints extends jspb.Message { 
            getMin(): number;
            setMin(value: number): FloatConstraints;
            getMax(): number;
            setMax(value: number): FloatConstraints;

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

        export namespace FloatConstraints {
            export type AsObject = {
                min: number,
                max: number,
            }
        }


        export enum ConstraintsCase {
            CONSTRAINTS_NOT_SET = 0,
            STRING_CONSTRAINTS = 1,
            INT_CONSTRAINTS = 2,
            FLOAT_CONSTRAINTS = 3,
        }

    }

    export class UIHints extends jspb.Message { 
        getWidget(): PipelineTemplateParameter.UIHints.UIWidget;
        setWidget(value: PipelineTemplateParameter.UIHints.UIWidget): UIHints;
        getDataSource(): string;
        setDataSource(value: string): UIHints;
        getSerializeAsString(): boolean;
        setSerializeAsString(value: boolean): UIHints;

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

    export namespace UIHints {
        export type AsObject = {
            widget: PipelineTemplateParameter.UIHints.UIWidget,
            dataSource: string,
            serializeAsString: boolean,
        }

        export enum UIWidget {
    UI_WIDGET_UNSPECIFIED = 0,
    TEXT_INPUT = 1,
    NUMBER_INPUT = 2,
    SLIDER = 3,
    DROPDOWN = 4,
    TOGGLE = 5,
        }

    }


    export enum Type {
    PARAMETER_TYPE_UNSPECIFIED = 0,
    STRING = 1,
    INT = 2,
    FLOAT = 3,
    BOOL = 4,
    }


    export enum DefaultValueCase {
        DEFAULT_VALUE_NOT_SET = 0,
        DEFAULT_STRING = 4,
        DEFAULT_INT = 5,
        DEFAULT_FLOAT = 6,
        DEFAULT_BOOL = 7,
    }

}

export class PipelineTemplate extends jspb.Message { 
    getName(): string;
    setName(value: string): PipelineTemplate;
    getDescription(): string;
    setDescription(value: string): PipelineTemplate;
    getPipelineTemplateType(): PipelineTemplate.PipelineTemplateType;
    setPipelineTemplateType(value: PipelineTemplate.PipelineTemplateType): PipelineTemplate;

    hasComputeInfo(): boolean;
    clearComputeInfo(): void;
    getComputeInfo(): ComputeInfo | undefined;
    setComputeInfo(value?: ComputeInfo): PipelineTemplate;
    clearParametersList(): void;
    getParametersList(): Array<PipelineTemplateParameter>;
    setParametersList(value: Array<PipelineTemplateParameter>): PipelineTemplate;
    addParameters(value?: PipelineTemplateParameter, index?: number): PipelineTemplateParameter;

    getPipelineStepsMap(): jspb.Map<string, string>;
    clearPipelineStepsMap(): void;

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

export namespace PipelineTemplate {
    export type AsObject = {
        name: string,
        description: string,
        pipelineTemplateType: PipelineTemplate.PipelineTemplateType,
        computeInfo?: ComputeInfo.AsObject,
        parametersList: Array<PipelineTemplateParameter.AsObject>,

        pipelineStepsMap: Array<[string, string]>,
    }

    export enum PipelineTemplateType {
    UNKNOWN = 0,
    TRAINING = 1,
    }

}

export class Secret extends jspb.Message { 
    getId(): string;
    setId(value: string): Secret;
    getUserId(): string;
    setUserId(value: string): Secret;
    getValue(): string;
    setValue(value: string): Secret;
    getVersion(): number;
    setVersion(value: number): Secret;
    getDescription(): string;
    setDescription(value: string): Secret;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Secret;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Secret;

    hasExpiresAt(): boolean;
    clearExpiresAt(): void;
    getExpiresAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setExpiresAt(value?: google_protobuf_timestamp_pb.Timestamp): Secret;

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

export namespace Secret {
    export type AsObject = {
        id: string,
        userId: string,
        value: string,
        version: number,
        description: string,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        expiresAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class MetricData extends jspb.Message { 

    hasMatrixData(): boolean;
    clearMatrixData(): void;
    getMatrixData(): MetricData.MatrixData | undefined;
    setMatrixData(value?: MetricData.MatrixData): MetricData;

    getDataCase(): MetricData.DataCase;

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

export namespace MetricData {
    export type AsObject = {
        matrixData?: MetricData.MatrixData.AsObject,
    }


    export class Label extends jspb.Message { 
        getName(): MetricLabel;
        setName(value: MetricLabel): Label;
        getValue(): string;
        setValue(value: string): Label;

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

    export namespace Label {
        export type AsObject = {
            name: MetricLabel,
            value: string,
        }
    }

    export class MetricSample extends jspb.Message { 

        hasTimestamp(): boolean;
        clearTimestamp(): void;
        getTimestamp(): google_protobuf_timestamp_pb.Timestamp | undefined;
        setTimestamp(value?: google_protobuf_timestamp_pb.Timestamp): MetricSample;
        getValue(): number;
        setValue(value: number): MetricSample;

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

    export namespace MetricSample {
        export type AsObject = {
            timestamp?: google_protobuf_timestamp_pb.Timestamp.AsObject,
            value: number,
        }
    }

    export class MatrixData extends jspb.Message { 
        clearSeriesList(): void;
        getSeriesList(): Array<MetricData.MatrixData.TimeSeries>;
        setSeriesList(value: Array<MetricData.MatrixData.TimeSeries>): MatrixData;
        addSeries(value?: MetricData.MatrixData.TimeSeries, index?: number): MetricData.MatrixData.TimeSeries;

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

    export namespace MatrixData {
        export type AsObject = {
            seriesList: Array<MetricData.MatrixData.TimeSeries.AsObject>,
        }


        export class TimeSeries extends jspb.Message { 
            clearLabelsList(): void;
            getLabelsList(): Array<MetricData.Label>;
            setLabelsList(value: Array<MetricData.Label>): TimeSeries;
            addLabels(value?: MetricData.Label, index?: number): MetricData.Label;
            clearValueList(): void;
            getValueList(): Array<MetricData.MetricSample>;
            setValueList(value: Array<MetricData.MetricSample>): TimeSeries;
            addValue(value?: MetricData.MetricSample, index?: number): MetricData.MetricSample;

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

        export namespace TimeSeries {
            export type AsObject = {
                labelsList: Array<MetricData.Label.AsObject>,
                valueList: Array<MetricData.MetricSample.AsObject>,
            }
        }

    }


    export enum DataCase {
        DATA_NOT_SET = 0,
        MATRIX_DATA = 1,
    }

}

export class MetricAggregate extends jspb.Message { 
    getOperator(): MetricAggregate.Operator;
    setOperator(value: MetricAggregate.Operator): MetricAggregate;
    clearLabelsList(): void;
    getLabelsList(): Array<MetricLabel>;
    setLabelsList(value: Array<MetricLabel>): MetricAggregate;
    addLabels(value: MetricLabel, index?: number): MetricLabel;

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

export namespace MetricAggregate {
    export type AsObject = {
        operator: MetricAggregate.Operator,
        labelsList: Array<MetricLabel>,
    }

    export enum Operator {
    OPERATOR_NOT_SET = 0,
    AVG = 1,
    SUM = 2,
    MAX = 3,
    MIN = 4,
    P95 = 5,
    P99 = 6,
    P50 = 7,
    COUNT = 8,
    }

}

export class MetricFilter extends jspb.Message { 
    getLabel(): MetricLabel;
    setLabel(value: MetricLabel): MetricFilter;

    hasEquals(): boolean;
    clearEquals(): void;
    getEquals(): string;
    setEquals(value: string): MetricFilter;

    hasIn(): boolean;
    clearIn(): void;
    getIn(): MetricFilter.MultiValues | undefined;
    setIn(value?: MetricFilter.MultiValues): MetricFilter;

    getValueCase(): MetricFilter.ValueCase;

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

export namespace MetricFilter {
    export type AsObject = {
        label: MetricLabel,
        equals: string,
        pb_in?: MetricFilter.MultiValues.AsObject,
    }


    export class MultiValues extends jspb.Message { 
        clearInList(): void;
        getInList(): Array<string>;
        setInList(value: Array<string>): MultiValues;
        addIn(value: string, index?: number): string;

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

    export namespace MultiValues {
        export type AsObject = {
            pb_inList: Array<string>,
        }
    }


    export enum ValueCase {
        VALUE_NOT_SET = 0,
        EQUALS = 2,
        IN = 3,
    }

}

export class MetricSearchQuery extends jspb.Message { 
    getMetricType(): MetricType;
    setMetricType(value: MetricType): MetricSearchQuery;

    hasStartTime(): boolean;
    clearStartTime(): void;
    getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): MetricSearchQuery;

    hasEndTime(): boolean;
    clearEndTime(): void;
    getEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setEndTime(value?: google_protobuf_timestamp_pb.Timestamp): MetricSearchQuery;
    getResolution(): string;
    setResolution(value: string): MetricSearchQuery;
    clearFiltersList(): void;
    getFiltersList(): Array<MetricFilter>;
    setFiltersList(value: Array<MetricFilter>): MetricSearchQuery;
    addFilters(value?: MetricFilter, index?: number): MetricFilter;

    hasAggregate(): boolean;
    clearAggregate(): void;
    getAggregate(): MetricAggregate | undefined;
    setAggregate(value?: MetricAggregate): MetricSearchQuery;

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

export namespace MetricSearchQuery {
    export type AsObject = {
        metricType: MetricType,
        startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        resolution: string,
        filtersList: Array<MetricFilter.AsObject>,
        aggregate?: MetricAggregate.AsObject,
    }
}

export class MetricTypeLabels extends jspb.Message { 
    getMetricType(): MetricType;
    setMetricType(value: MetricType): MetricTypeLabels;
    clearLabelsList(): void;
    getLabelsList(): Array<MetricTypeLabels.LabelWithValues>;
    setLabelsList(value: Array<MetricTypeLabels.LabelWithValues>): MetricTypeLabels;
    addLabels(value?: MetricTypeLabels.LabelWithValues, index?: number): MetricTypeLabels.LabelWithValues;

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

export namespace MetricTypeLabels {
    export type AsObject = {
        metricType: MetricType,
        labelsList: Array<MetricTypeLabels.LabelWithValues.AsObject>,
    }


    export class LabelWithValues extends jspb.Message { 
        getLabel(): MetricLabel;
        setLabel(value: MetricLabel): LabelWithValues;
        clearValuesList(): void;
        getValuesList(): Array<string>;
        setValuesList(value: Array<string>): LabelWithValues;
        addValues(value: string, index?: number): string;

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

    export namespace LabelWithValues {
        export type AsObject = {
            label: MetricLabel,
            valuesList: Array<string>,
        }
    }

}

export class Artifact extends jspb.Message { 
    getId(): string;
    setId(value: string): Artifact;
    getUserId(): string;
    setUserId(value: string): Artifact;
    getAppId(): string;
    setAppId(value: string): Artifact;

    hasArtifactVersion(): boolean;
    clearArtifactVersion(): void;
    getArtifactVersion(): ArtifactVersion | undefined;
    setArtifactVersion(value?: ArtifactVersion): Artifact;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): Artifact;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): Artifact;

    hasDeletedAt(): boolean;
    clearDeletedAt(): void;
    getDeletedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDeletedAt(value?: google_protobuf_timestamp_pb.Timestamp): Artifact;

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

export namespace Artifact {
    export type AsObject = {
        id: string,
        userId: string,
        appId: string,
        artifactVersion?: ArtifactVersion.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        deletedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class ArtifactVersion extends jspb.Message { 
    getId(): string;
    setId(value: string): ArtifactVersion;
    getDescription(): string;
    setDescription(value: string): ArtifactVersion;

    hasArtifact(): boolean;
    clearArtifact(): void;
    getArtifact(): Artifact | undefined;
    setArtifact(value?: Artifact): ArtifactVersion;

    hasUpload(): boolean;
    clearUpload(): void;
    getUpload(): Upload | undefined;
    setUpload(value?: Upload): ArtifactVersion;

    hasVisibility(): boolean;
    clearVisibility(): void;
    getVisibility(): Visibility | undefined;
    setVisibility(value?: Visibility): ArtifactVersion;

    hasExpiresAt(): boolean;
    clearExpiresAt(): void;
    getExpiresAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setExpiresAt(value?: google_protobuf_timestamp_pb.Timestamp): ArtifactVersion;

    hasCreatedAt(): boolean;
    clearCreatedAt(): void;
    getCreatedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setCreatedAt(value?: google_protobuf_timestamp_pb.Timestamp): ArtifactVersion;

    hasModifiedAt(): boolean;
    clearModifiedAt(): void;
    getModifiedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setModifiedAt(value?: google_protobuf_timestamp_pb.Timestamp): ArtifactVersion;

    hasDeletedAt(): boolean;
    clearDeletedAt(): void;
    getDeletedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDeletedAt(value?: google_protobuf_timestamp_pb.Timestamp): ArtifactVersion;

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

export namespace ArtifactVersion {
    export type AsObject = {
        id: string,
        description: string,
        artifact?: Artifact.AsObject,
        upload?: Upload.AsObject,
        visibility?: Visibility.AsObject,
        expiresAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        createdAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        modifiedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        deletedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export enum WorkflowModelUseCase {
    WORKFLOW_MODEL_USE_CASE_NOT_SET = 0,
    CLASSIFICATION = 1,
    DETECTION = 2,
}

export enum DatasetVersionRequestOrigin {
    DATASET_VERSION_REQUEST_ORIGIN_NOT_SET = 0,
    MANUAL = 1,
    TRAINING = 2,
    EVAL_GROUND_TRUTH = 3,
    EVAL_PREDICTIONS = 4,
}

export enum DatasetVersionMetricsGroupType {
    DATASET_VERSION_METRICS_GROUP_TYPE_NOT_SET = 0,
    INPUT_TYPE = 2,
    CONCEPT_ID = 10,
    CONCEPTS_COUNT = 11,
    BOUNDING_BOXES_COUNT = 20,
    POLYGONS_COUNT = 21,
    POINTS_COUNT = 22,
    MASKS_COUNT = 23,
    PIXELS_COUNT = 30,
    ASPECT_RATIO = 31,
}

export enum DatasetVersionExportFormat {
    DATASET_VERSION_EXPORT_FORMAT_NOT_SET = 0,
    CLARIFAI_DATA_PROTOBUF = 1,
    CLARIFAI_DATA_JSON = 3,
    COCO = 2,
}

export enum LicenseType {
    UNKNOWN_LICENSE_TYPE = 0,
    FIRST_PARTY = 1,
    OPEN_SOURCE = 2,
    CLOSED_SOURCE = 3,
}

export enum DeployRestriction {
    USAGE_RESTRICTION_NOT_SET = 0,
    NO_LIMITS = 1,
    SHARED_COMPUTE_ONLY = 2,
    DEDICATED_COMPUTE_ONLY = 3,
    MODEL_OWNER_DEDICATED_COMPUTE_ONLY = 4,
}

export enum DataType {
    UNDEFINED = 0,
    STRING = 1,
    UINT8 = 2,
    INT32 = 3,
    INT64 = 4,
    FP32 = 5,
}

export enum ValueComparator {
    CONCEPT_THRESHOLD_NOT_SET = 0,
    GREATER_THAN = 1,
    GREATER_THAN_OR_EQUAL = 2,
    LESS_THAN = 3,
    LESS_THAN_OR_EQUAL = 4,
    EQUAL = 5,
}

export enum EvaluationType {
    UNDEFINED = 0,
    CLASSIFICATION = 1,
    DETECTION = 2,
    SEGMENTATION = 3,
    CLUSTERING = 4,
    TRACKER = 5,
    GENERATION = 6,
}

export enum APIEventType {
    API_EVENT_TYPE_NOT_SET = 0,
    ON_PREM_PREDICT = 1,
    ON_PREM_TRAIN = 2,
    ON_PREM_SEARCH = 3,
}

export enum UsageIntervalType {
    UNDEF = 0,
    DAY = 1,
    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,
}

export enum ValidationErrorType {
    VALIDATION_ERROR_TYPE_NOT_SET = 0,
    RESTRICTED = 1,
    DATABASE = 2,
    FORMAT = 3,
}

export enum InputIDConflictResolution {
    INPUT_ID_CONFLICT_RESOLUTION_NOT_SET = 0,
    SKIP = 1,
    SUFFIX = 2,
}

export enum RunnerMethodType {
    UNKNOWN = 0,
    UNARY_UNARY = 1,
    UNARY_STREAMING = 2,
    STREAMING_UNARY = 3,
    STREAMING_STREAMING = 4,
}

export enum EventType {
    EVENT_TYPE_NOT_SET = 0,
    ORGANIZATION_MEMBER_ADD = 100,
    ORGANIZATION_MEMBER_CHANGE = 101,
    ORGANIZATION_MEMBER_REMOVE = 102,
    ORGANIZATION_MEMBER_INVITATION_CREATE = 103,
    ORGANIZATION_MEMBER_INVITATION_CANCEL = 104,
    ORGANIZATION_MEMBER_INVITATION_ACCEPT = 105,
    ORGANIZATION_MEMBER_INVITATION_DECLINE = 106,
    ORGANIZATION_TEAM_CREATE = 107,
    ORGANIZATION_TEAM_UPDATE = 108,
    ORGANIZATION_TEAM_DELETE = 109,
    ORGANIZATION_TEAM_MEMBER_ADD = 110,
    ORGANIZATION_TEAM_MEMBER_REMOVE = 111,
    ORGANIZATION_TEAM_APP_ADD = 112,
    ORGANIZATION_TEAM_APP_REMOVE = 113,
    MODEL_CREATE = 300,
    MODEL_UPDATE = 301,
    MODEL_DELETE = 302,
    MODEL_VERSION_CREATE = 303,
    MODEL_VERSION_UPDATE = 304,
    MODEL_VERSION_DELETE = 305,
    WORKFLOW_CREATE = 400,
    WORKFLOW_UPDATE = 401,
    WORKFLOW_DELETE = 402,
    WORKFLOW_VERSION_CREATE = 403,
    WORKFLOW_VERSION_UPDATE = 404,
    WORKFLOW_VERSION_DELETE = 405,
    APPLICATION_CREATE = 600,
    APPLICATION_UPDATE = 601,
    APPLICATION_DELETE = 602,
    COLLABORATOR_ADD = 700,
    COLLABORATOR_UPDATE = 701,
    COLLABORATOR_REMOVE = 702,
    USER_UPDATE = 800,
    COMPUTE_CLUSTER_CREATE = 900,
    COMPUTE_CLUSTER_UPDATE = 902,
    COMPUTE_CLUSTER_DELETE = 901,
    NODEPOOL_CREATE = 1000,
    NODEPOOL_UPDATE = 1001,
    NODEPOOL_DELETE = 1002,
    DEPLOYMENT_CREATE = 1100,
    DEPLOYMENT_UPDATE = 1101,
    DEPLOYMENT_DELETE = 1102,
}

export enum MetricType {
    METRIC_TYPE_NOT_SET = 0,
    MODEL_TTFT = 1,
    MODEL_THROUGHPUT = 2,
    MODEL_PROMPT_TOKEN_THROUGHPUT = 3,
    MODEL_COMPLETION_TOKEN_THROUGHPUT = 4,
    MODEL_REQUEST_COUNT = 5,
    MODEL_E2E_LATENCY = 6,
    NODEPOOL_NODE_COUNT = 51,
    NODEPOOL_GPU_UTILIZATION = 52,
    NODEPOOL_GPU_TENSOR_UTILIZATION = 53,
    NODEPOOL_GPU_MEMORY_UTILIZATION = 54,
    NODEPOOL_CPU_UTILIZATION = 55,
    NODEPOOL_MEMORY_UTILIZATION = 56,
}

export enum MetricLabel {
    METRIC_LABEL_NOT_SET = 0,
    APP_ID = 1,
    MODEL_ID = 2,
    MODEL_VERSION_ID = 3,
    HTTP_STATUS = 4,
    COMPUTE_CLUSTER_ID = 5,
    NODEPOOL_ID = 6,
}