{
  "type": "object",
  "title": "This represents a relation (i.e. edge) between the subject concept and the object concept",
  "properties": {
    "id": {
      "type": "string",
      "title": "ID of the concept relation"
    },
    "predicate": {
      "type": "string",
      "description": "The predicate (i.e. edge) linking the subject and the object\nBoth subject_concept and object_concept are concepts.\nThe predicate is the type of relationship.\nThat predicate acts on the subject.\n\nThere are three current types of predicates:\n1) \"hyponym\"\n2) \"hypernym\"\n3) \"synonym\"\n\n1) For example, 'hyponym' is a type of predicate which represents 'is_a_kind_of' relation so\nthe following relationship:\n'honey' (subject), 'hyponym' (predicate), 'food' (object)\nCan more easily be read as:\n'honey' 'is a kind of' 'food'\n\n\n2) The 'hypernym' relation is the opposite of 'hyponym' and when you add one of the\nrelationships the opposite will automatically appear for you in queries.\n\nThe 'hypernym' can be read as 'is a parent of' so:\n'food' (subject), 'hypernym' (predicate), 'honey' (object)\nCan more easily be read as:\n'food' is a parent of 'honey'\n\n3) The 'synonym' relation defines two concepts that essential mean the same thing. This\nis more like a \"is\" relationship. So for example a 'synonym' relationship could be:\n\"puppy\" is \"pup\"\nThe reverse is also true once the former is added so:\n\"pup\" is \"puppy\"\nwill appear in queries as well."
    },
    "visibility": {
      "$ref": "#/components/schemas/clarifaiapiVisibility"
    },
    "objectConcept": {
      "$ref": "#/components/schemas/apiConcept"
    },
    "subjectConcept": {
      "$ref": "#/components/schemas/apiConcept"
    },
    "knowledgeGraphId": {
      "type": "string",
      "description": "The knowledge graph id that this edge belongs to. If using the app's global knowledge graph\nand not a specific one then this should be the empty string \"\"."
    }
  }
}

{
  "type": "object",
  "title": "ConceptTypeCount",
  "properties": {
    "negative": {
      "type": "integer",
      "format": "int64",
      "description": "The number of inputs that have a concept with a value of 0.0 (indicating absence of the\nconcept in an input)."
    },
    "positive": {
      "type": "integer",
      "format": "int64",
      "description": "The number of inputs that have a concept with a value of 1.0 (indicating presence of the\nconcept in an input)."
    }
  }
}

{
  "type": "object",
  "title": "ConfusionMatrix",
  "properties": {
    "matrix": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiConfusionMatrixEntry"
      }
    },
    "conceptIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "These concept_ids are ordered by the strength of the diagonal in the ConfusionMatrix."
    }
  }
}

{
  "type": "object",
  "title": "ConfusionMatrixEntry",
  "properties": {
    "value": {
      "type": "number",
      "format": "float"
    },
    "actual": {
      "type": "string"
    },
    "predicted": {
      "type": "string"
    },
    "actualConcept": {
      "$ref": "#/components/schemas/apiConcept"
    },
    "predictedConcept": {
      "$ref": "#/components/schemas/apiConcept"
    }
  }
}

{
  "type": "object",
  "title": "CooccurrenceMatrix",
  "properties": {
    "matrix": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiCooccurrenceMatrixEntry"
      }
    },
    "conceptIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "These concept_ids are ordered by the strength of the diagonal in the ConfusionMatrix."
    }
  }
}

{
  "type": "object",
  "title": "NOTE: this is inefficient, should just have the order of the rows/cols",
  "properties": {
    "col": {
      "type": "string",
      "title": "concept_id for the col"
    },
    "row": {
      "type": "string",
      "title": "concept_id for the row"
    },
    "count": {
      "type": "integer",
      "format": "int64"
    }
  }
}

{
  "type": "object",
  "title": "Data",
  "properties": {
    "geo": {
      "$ref": "#/components/schemas/apiGeo"
    },
    "hits": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiHit"
      },
      "title": "Holds score, rank, and user, app, input IDs and search hit data"
    },
    "text": {
      "$ref": "#/components/schemas/apiText"
    },
    "audio": {
      "$ref": "#/components/schemas/apiAudio"
    },
    "image": {
      "$ref": "#/components/schemas/apiImage"
    },
    "video": {
      "$ref": "#/components/schemas/apiVideo"
    },
    "colors": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiColor"
      },
      "description": "The dominant colors within an image."
    },
    "frames": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiFrame"
      },
      "description": "For temporal content like video."
    },
    "tracks": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiTrack"
      },
      "description": "Track information."
    },
    "regions": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiRegion"
      },
      "description": "For recursing into localized regions of an input."
    },
    "clusters": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiCluster"
      },
      "description": "Clustering centroids for inputs."
    },
    "concepts": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiConcept"
      },
      "description": "A list of concepts."
    },
    "heatmaps": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiImage"
      },
      "title": "Heatmap as 2d image"
    },
    "metadata": {
      "type": "object",
      "title": "To handle arbitrary json metadata you can use a struct field:\nhttps://github.com/google/protobuf/blob/master/src/google/protobuf/struct.proto"
    },
    "embeddings": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiEmbedding"
      },
      "description": "Embedding vectors representing each input."
    },
    "timeSegments": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiTimeSegment"
      },
      "description": "Time segments information."
    }
  }
}

{
  "type": "object",
  "properties": {
    "s3Creds": {
      "$ref": "#/components/schemas/apiAWSCreds"
    },
    "gcpCreds": {
      "type": "string",
      "format": "byte",
      "description": "GCP Cloud Storage uses service account key data(creds.json) as Byte array for authentication."
    },
    "azureBlobCreds": {
      "$ref": "#/components/schemas/apiAzureBlobCreds"
    }
  }
}

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "description": "Supported providers are AWS S3, Azure blob, GCP cloud storage."
    },
    "credentials": {
      "$ref": "#/components/schemas/apiDataSourceCredentials"
    }
  }
}

{
  "enum": [
    "UNDEFINED",
    "STRING",
    "UINT8",
    "INT32",
    "INT64",
    "FP32"
  ],
  "type": "string",
  "title": "- UNDEFINED: Default value, should not be used",
  "default": "UNDEFINED"
}

{
  "type": "object",
  "title": "Dataset",
  "properties": {
    "id": {
      "type": "string",
      "title": "The ID for the dataset"
    },
    "appId": {
      "type": "string",
      "description": "The app the dataset belongs to."
    },
    "image": {
      "$ref": "#/components/schemas/apiImage"
    },
    "notes": {
      "type": "string",
      "description": "Notes for the dataset\nThis field should be used for in-depth notes and supports up to 64Kbs."
    },
    "userId": {
      "type": "string",
      "description": "The user the dataset belongs to."
    },
    "version": {
      "$ref": "#/components/schemas/apiDatasetVersion"
    },
    "metadata": {
      "type": "object",
      "title": "To handle arbitrary json metadata you can use a struct field:\nhttps://github.com/google/protobuf/blob/master/src/google/protobuf/struct.proto"
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the dataset was created.\nThe format is https://www.ietf.org/rfc/rfc3339.txt.\nExample: \"2006-01-02T15:04:05.999999Z\"."
    },
    "isStarred": {
      "type": "boolean",
      "description": "Whether the dataset is starred by the requesting user."
    },
    "starCount": {
      "type": "integer",
      "format": "int32",
      "description": "Number of users that starred this dataset."
    },
    "modifiedAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the dataset was modified.\nThe format is https://www.ietf.org/rfc/rfc3339.txt.\nExample: \"2006-01-02T15:04:05.999999Z\"."
    },
    "visibility": {
      "$ref": "#/components/schemas/clarifaiapiVisibility"
    },
    "description": {
      "type": "string",
      "title": "Description of the dataset"
    },
    "bookmarkOrigin": {
      "$ref": "#/components/schemas/apiBookmarkOrigin"
    },
    "defaultProcessingInfo": {
      "$ref": "#/components/schemas/apiDatasetVersionProcessingInfo"
    },
    "defaultAnnotationFilter": {
      "$ref": "#/components/schemas/apiAnnotationFilter"
    }
  }
}

{
  "type": "object",
  "title": "DatasetInput",
  "properties": {
    "input": {
      "$ref": "#/components/schemas/apiInput"
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the input was added to the dataset.\nThe format is https://www.ietf.org/rfc/rfc3339.txt.\nExample: \"2006-01-02T15:04:05.999999Z\"."
    }
  }
}

{
  "type": "object",
  "properties": {
    "dataset": {
      "$ref": "#/components/schemas/apiDataset"
    },
    "percentage": {
      "type": "integer",
      "title": "For RANDOM_PERCENTAGE_SPLIT.\nValues from (0,100]",
      "format": "int64"
    }
  }
}

{
  "type": "object",
  "title": "DatasetVersion",
  "properties": {
    "id": {
      "type": "string",
      "title": "The ID for the dataset version"
    },
    "appId": {
      "type": "string",
      "description": "The app the dataset version belongs to."
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "userId": {
      "type": "string",
      "description": "The user the dataset version belongs to."
    },
    "metrics": {
      "type": "object",
      "title": "Dataset version metrics",
      "additionalProperties": {
        "$ref": "#/components/schemas/apiDatasetVersionMetrics"
      }
    },
    "metadata": {
      "type": "object",
      "title": "To handle arbitrary json metadata you can use a struct field:\nhttps://github.com/google/protobuf/blob/master/src/google/protobuf/struct.proto"
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the dataset version was created.\nThe format is https://www.ietf.org/rfc/rfc3339.txt.\nExample: \"2006-01-02T15:04:05.999999Z\"."
    },
    "datasetId": {
      "type": "string",
      "description": "The dataset the dataset version belongs to."
    },
    "exportInfo": {
      "$ref": "#/components/schemas/apiDatasetVersionExportInfo"
    },
    "modifiedAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the dataset version was modified.\nThe format is https://www.ietf.org/rfc/rfc3339.txt.\nExample: \"2006-01-02T15:04:05.999999Z\"."
    },
    "visibility": {
      "$ref": "#/components/schemas/clarifaiapiVisibility"
    },
    "description": {
      "type": "string",
      "title": "Description of the dataset version"
    },
    "processingInfo": {
      "$ref": "#/components/schemas/apiDatasetVersionProcessingInfo"
    },
    "modelPredictConfig": {
      "$ref": "#/components/schemas/apiModelPredictConfig"
    },
    "embedModelVersionIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The embedding models to return embeddings for. If empty, no embeddings are returned."
    },
    "annotationFilterConfig": {
      "$ref": "#/components/schemas/apiAnnotationFilterConfig"
    }
  }
}

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "description": "url is the URL from where the dataset version export can be downloaded."
    },
    "size": {
      "type": "string",
      "format": "uint64",
      "description": "size is the size of the dataset version export in number of bytes."
    },
    "format": {
      "$ref": "#/components/schemas/apiDatasetVersionExportFormat"
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "includeEmbeddings": {
      "type": "boolean",
      "description": "whether to include embeddings in the export or not."
    }
  },
  "description": "DatasetVersionExport contains metadata for a single dataset version export."
}

{
  "enum": [
    "DATASET_VERSION_EXPORT_FORMAT_NOT_SET",
    "CLARIFAI_DATA_PROTOBUF",
    "CLARIFAI_DATA_JSON",
    "COCO"
  ],
  "type": "string",
  "default": "DATASET_VERSION_EXPORT_FORMAT_NOT_SET",
  "description": " - CLARIFAI_DATA_PROTOBUF: CLARIFAI_DATA_PROTOBUF is the proprietary Clarifai API Data format. It\nis a ZIP-archive containing batches of serialized InputBatch protobuf messages.\n\nNote that only the \"id\" and \"data\" fields of exported inputs are set.\n - CLARIFAI_DATA_JSON: CLARIFAI_DATA_JSON is the proprietary Clarifai API Data format in JSON. It\nis a ZIP-archive containing batches of serialized InputBatch JSON messages.\n\nNote that only the \"id\" and \"data\" fields of exported inputs are set.\n - COCO: COCO is the data format used by Common Objects in Context. It is a\nZIP-archive containing JSON files with the dataset version annotations.\nSee https://cocodataset.org/#format-data."
}

{
  "type": "object",
  "properties": {
    "coco": {
      "$ref": "#/components/schemas/apiDatasetVersionExport"
    },
    "clarifaiDataJson": {
      "$ref": "#/components/schemas/apiDatasetVersionExport"
    },
    "clarifaiDataProtobuf": {
      "$ref": "#/components/schemas/apiDatasetVersionExport"
    }
  },
  "description": "DatasetVersionExportInfo contains information about all exports of a dataset version.\n\nIf the dataset version has not been exported in a format, then the DatasetVersionExport\nfield for that format is empty instead of having a \"not exported\" status."
}

{
  "type": "object",
  "properties": {
    "masksCount": {
      "type": "string",
      "title": "Number of masks",
      "format": "uint64"
    },
    "framesCount": {
      "type": "string",
      "title": "Number of frames",
      "format": "uint64"
    },
    "inputsCount": {
      "type": "string",
      "title": "Number of inputs",
      "format": "uint64"
    },
    "pointsCount": {
      "type": "string",
      "title": "Number of points",
      "format": "uint64"
    },
    "regionsCount": {
      "type": "string",
      "title": "Number of regions",
      "format": "uint64"
    },
    "polygonsCount": {
      "type": "string",
      "title": "Number of polygons",
      "format": "uint64"
    },
    "embeddingsCount": {
      "type": "string",
      "title": "Number of embeddings",
      "format": "uint64"
    },
    "frameInputsCount": {
      "type": "string",
      "title": "Number of inputs that have frames attached",
      "format": "uint64"
    },
    "regionFramesCount": {
      "type": "string",
      "title": "Number of frames that have regions attached",
      "format": "uint64"
    },
    "regionInputsCount": {
      "type": "string",
      "format": "uint64",
      "description": "Number of inputs that have regions attached\nNote that this is not a recursive count: if an input contains frames that contains regions, then the region_frames_count is increased, but region_inputs_count is not increased."
    },
    "boundingBoxesCount": {
      "type": "string",
      "title": "Number of bounding boxes",
      "format": "uint64"
    },
    "inputsWithGeoCount": {
      "type": "string",
      "title": "Number of inputs that have geo information",
      "format": "uint64"
    },
    "regionLocationMatrix": {
      "$ref": "#/components/schemas/MatrixUint64"
    },
    "unlabeledInputsCount": {
      "type": "string",
      "format": "uint64",
      "description": "Number of unlabeled inputs\nAn input is considered unlabeled if it there are no annotations with positive labels for that input."
    },
    "positiveFrameTagsCount": {
      "type": "string",
      "title": "Number of positive tags added at frame-level",
      "format": "uint64"
    },
    "positiveInputTagsCount": {
      "type": "string",
      "title": "Number of positive tags added at input-level",
      "format": "uint64"
    },
    "inputsWithMetadataCount": {
      "type": "string",
      "title": "Number of inputs that have metadata",
      "format": "uint64"
    },
    "positiveRegionTagsCount": {
      "type": "string",
      "title": "Number of positive tags added at region-level",
      "format": "uint64"
    }
  }
}

{
  "type": "object",
  "properties": {
    "type": {
      "$ref": "#/components/schemas/apiDatasetVersionMetricsGroupType"
    },
    "value": {},
    "metrics": {
      "$ref": "#/components/schemas/apiDatasetVersionMetrics"
    },
    "parentPath": {
      "type": "string"
    }
  }
}

{
  "enum": [
    "DATASET_VERSION_METRICS_GROUP_TYPE_NOT_SET",
    "INPUT_TYPE",
    "CONCEPT_ID",
    "CONCEPTS_COUNT",
    "BOUNDING_BOXES_COUNT",
    "POLYGONS_COUNT",
    "POINTS_COUNT",
    "MASKS_COUNT",
    "PIXELS_COUNT",
    "ASPECT_RATIO"
  ],
  "type": "string",
  "default": "DATASET_VERSION_METRICS_GROUP_TYPE_NOT_SET",
  "description": " - INPUT_TYPE: Group data examples by input type.\nExamples: images, videos, text, audio.\n - CONCEPT_ID: Group data examples by concept ID.\nExamples: inputs with cat concept, inputs with dog concept.\n - CONCEPTS_COUNT: Group data examples by concepts count.\nExamples: inputs with 20 concepts, inputs with 21 concepts.\n - BOUNDING_BOXES_COUNT: Group data examples by bounding boxes count.\nExamples: inputs with 20 bounding boxes, inputs with 21 bounding boxes.\n - POLYGONS_COUNT: Group data examples by polygons count.\nExamples: inputs with 20 polygons, inputs with 21 polygons.\n - POINTS_COUNT: Group data examples by points count.\nExamples: inputs with 20 points, inputs with 21 points.\n - MASKS_COUNT: Group data examples by masks count.\nExamples: inputs with 20 masks, inputs with 21 masks.\n - PIXELS_COUNT: Group data examples by pixels count.\nIn order to reduce the number of groups, we use bins.\nExamples for bin size = 400: inputs with [200000, 200400) pixels, inputs with [200400, 200800) pixels.\n - ASPECT_RATIO: Group data examples by aspect ratio.\nIn order to reduce the number of groups, we use bins.\nExamples for bin size = 0.1: inputs with [0.5, 0.6) aspect ratio, inputs with [0.6, 0.7) aspect ratio."
}

{
  "type": "object",
  "properties": {
    "frameInterpolationInfo": {
      "$ref": "#/components/schemas/apiFrameInterpolationInfo"
    }
  },
  "description": "DatasetVersionProcessingInfo contains information about processing applied\nto a dataset version."
}

{
  "type": "object",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "annotationFilterIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Specify which filters to delete."
    }
  },
  "description": "Request to delete several annotation filters by list of ids."
}

{
  "type": "object",
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "Delete annotations with IDs"
    },
    "inputIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "Delete annotations for these Input IDs\nNote that 'ids' are optional but if the are provided the number and order in\n'ids' and 'input_ids' should match\nIf you do not specifiy 'ids' all the annotations for 'input_ids' are deleted\nHowever you need to specify at least one value for 'input_ids'\ni.e. this API does not support deleting all annotations"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  },
  "description": "Request to delete several things by the list of ids."
}

{
  "type": "object",
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "List of bulk operation ids to be deleted"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  },
  "description": "Request to delete the terminated bulk operations by ID\nOnly operations in terminated state can be deleted."
}

{
  "type": "object",
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "deleteAll": {
      "type": "boolean"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  },
  "description": "Request to delete several things by the list of ids."
}

{
  "type": "object",
  "properties": {
    "userIds": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "concepts": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiConcept"
      }
    }
  }
}

{
  "type": "object",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "datasetIds": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "description": "Request to delete several datasets by list of ids."
}

{
  "type": "object",
  "properties": {
    "datasetId": {
      "type": "string"
    }
  }
}

{
  "type": "object"
}

{
  "type": "object",
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  },
  "description": "Request to delete several things by the list of ids."
}

{
  "type": "object",
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  },
  "description": "Request to delete a list of label orders."
}

{
  "type": "object",
  "properties": {
    "metadata": {
      "type": "object",
      "title": "To handle arbitrary json metadata you can use a struct field:\nhttps://github.com/google/protobuf/blob/master/src/google/protobuf/struct.proto"
    }
  }
}

{
  "type": "object",
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "deleteAll": {
      "type": "boolean"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  },
  "description": "Request to delete several things by the list of ids."
}

{
  "type": "object",
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  },
  "description": "Request to delete a list of tasks."
}

{
  "type": "object",
  "title": "Stops or deletes multipart upload",
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  }
}

{
  "type": "object",
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "deleteAll": {
      "type": "boolean"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  },
  "description": "Request to delete several things by the list of ids."
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "An id for this configured deployment."
    },
    "model": {
      "$ref": "#/components/schemas/apiModel"
    },
    "userId": {
      "type": "string",
      "description": "The user who owns the deployment. These live in the user/org account."
    },
    "workflow": {
      "$ref": "#/components/schemas/apiWorkflow"
    },
    "nodepools": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiNodepool"
      },
      "title": "You can configure different autoscaling per nodepool(s).\nThese nodepools have to be also owned by the same user_id/org as this deployment.\nIf there is more than one nodepool we use the model's ComputeInfo to match\nwith what the nodepool provides to decide which one can handle it combined with the\nNodepoolRank below. Note: even within a single nodepool if it is heterogeneous then\nwe need a way to rank scheduling choices when we don't know how to decide (like a model\nsupports"
    },
    "autoscaleConfig": {
      "$ref": "#/components/schemas/apiAutoscaleConfig"
    },
    "schedulingChoice": {
      "$ref": "#/components/schemas/DeploymentSchedulingChoice"
    }
  },
  "description": "A deployment allows you to configure how runners for a particular type of resource will\nscale up and down. These are unique per user_id, nodepool and model so for differnet nodepools\nyou can scale differently."
}

{
  "type": "object",
  "title": "DetailConceptCount",
  "properties": {
    "errors": {
      "$ref": "#/components/schemas/apiConceptTypeCount"
    },
    "processed": {
      "$ref": "#/components/schemas/apiConceptTypeCount"
    },
    "toProcess": {
      "$ref": "#/components/schemas/apiConceptTypeCount"
    },
    "processing": {
      "$ref": "#/components/schemas/apiConceptTypeCount"
    }
  }
}

{
  "type": "object",
  "title": "EmailAddress",
  "properties": {
    "email": {
      "type": "string"
    },
    "primary": {
      "type": "boolean"
    },
    "verified": {
      "type": "boolean"
    }
  }
}

{
  "type": "object",
  "title": "Embedding",
  "properties": {
    "vector": {
      "type": "array",
      "items": {
        "type": "number",
        "format": "float"
      }
    },
    "numDimensions": {
      "type": "integer",
      "format": "int64"
    }
  }
}

{
  "type": "object",
  "title": "EndpointDeps",
  "properties": {
    "endpoint": {
      "type": "string",
      "title": "The fully qualified endpoint to"
    },
    "dependingScopes": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Other scopes that are required."
    }
  }
}

{
  "type": "object",
  "properties": {
    "params": {
      "type": "object",
      "description": "To control the evaluation process.\nAllow a list of parameters."
    }
  }
}

{
  "type": "object",
  "title": "EvalMetrics",
  "properties": {
    "id": {
      "type": "string",
      "title": "Id of this evaluation"
    },
    "appId": {
      "type": "string",
      "title": "app id that owns this evaluation"
    },
    "model": {
      "$ref": "#/components/schemas/apiModel"
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "userId": {
      "type": "string",
      "title": "user id that owns this evaluation"
    },
    "summary": {
      "$ref": "#/components/schemas/apiMetricsSummary"
    },
    "testSet": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiEvalTestSetEntry"
      }
    },
    "evalInfo": {
      "$ref": "#/components/schemas/apiEvalInfo"
    },
    "labelCounts": {
      "$ref": "#/components/schemas/apiLabelDistribution"
    },
    "binaryMetrics": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiBinaryMetrics"
      }
    },
    "metricsByArea": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiBinaryMetrics"
      }
    },
    "metricsByClass": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiBinaryMetrics"
      }
    },
    "trackerMetrics": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiTrackerMetrics"
      }
    },
    "confusionMatrix": {
      "$ref": "#/components/schemas/apiConfusionMatrix"
    },
    "extendedMetrics": {
      "$ref": "#/components/schemas/apiExtendedMetrics"
    },
    "cooccurrenceMatrix": {
      "$ref": "#/components/schemas/apiCooccurrenceMatrix"
    },
    "groundTruthDataset": {
      "$ref": "#/components/schemas/apiDataset"
    },
    "predictionsDataset": {
      "$ref": "#/components/schemas/apiDataset"
    }
  }
}

{
  "type": "object",
  "title": "EvalTestSetEntry",
  "properties": {
    "input": {
      "$ref": "#/components/schemas/apiInput"
    },
    "annotation": {
      "$ref": "#/components/schemas/clarifaiapiAnnotation"
    },
    "predictedConcepts": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiConcept"
      }
    },
    "groundTruthConcepts": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiConcept"
      },
      "title": "All the ground truth concepts will be show on the top level"
    }
  }
}

{
  "enum": [
    "Undefined",
    "Classification",
    "Detection",
    "Segmentation",
    "Clustering",
    "Tracker",
    "Generation"
  ],
  "type": "string",
  "title": "- Classification: default",
  "default": "Undefined"
}

{
  "type": "object",
  "properties": {
    "userMetrics": {
      "type": "object"
    }
  }
}

{
  "type": "object",
  "title": "FieldsValue",
  "properties": {
    "testSet": {
      "type": "boolean"
    },
    "labelCounts": {
      "type": "boolean"
    },
    "binaryMetrics": {
      "type": "boolean"
    },
    "metricsByArea": {
      "type": "boolean"
    },
    "metricsByClass": {
      "type": "boolean"
    },
    "confusionMatrix": {
      "type": "boolean"
    },
    "cooccurrenceMatrix": {
      "type": "boolean"
    }
  }
}

{
  "type": "object",
  "title": "Filter",
  "properties": {
    "input": {
      "$ref": "#/components/schemas/apiInput"
    },
    "negate": {
      "type": "boolean",
      "title": "If True then this will flip the meaning of this part of the\nquery. This allow for queries such as dog AND ! metadata=={\"blah\":\"value\"}"
    },
    "annotation": {
      "$ref": "#/components/schemas/clarifaiapiAnnotation"
    },
    "lastUpdatedTimeRange": {
      "$ref": "#/components/schemas/apiTimeRange"
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "An ID for the frame."
    },
    "data": {
      "$ref": "#/components/schemas/apiData"
    },
    "frameInfo": {
      "$ref": "#/components/schemas/apiFrameInfo"
    }
  },
  "description": "A Frame of time-series Data such as a Video."
}

{
  "type": "object",
  "properties": {
    "time": {
      "type": "integer",
      "format": "int64",
      "description": "time in the video in milliseconds. This is independent of the sampling rates used during\nprocessing."
    },
    "index": {
      "type": "integer",
      "title": "Deprecated. Use Time instead.\nThe index of the frame, informational and optional.\nDepends on the sampling rate used during processing\nMay be 0 for interpolated frames that are generated for brief time (training) or if new frame is manually added",
      "format": "int64"
    }
  },
  "description": "The information of the location of the Frame."
}