{
  "type": "object",
  "title": "Start concept mapping jobs",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "conceptMappingJobs": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiConceptMappingJob"
      },
      "title": "The concept mapping jobs that are being started"
    }
  }
}

{
  "type": "object",
  "title": "PostConceptsRequest",
  "properties": {
    "concepts": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiConcept"
      },
      "description": "The concepts to add."
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  }
}

{
  "type": "object",
  "title": "PostConceptsSearchesRequest",
  "properties": {
    "extraInfo": {
      "$ref": "#/components/schemas/apiConceptExtraInfoRequest"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "pagination": {
      "$ref": "#/components/schemas/apiPagination"
    },
    "conceptQuery": {
      "$ref": "#/components/schemas/apiConceptQuery"
    }
  }
}

{
  "type": "object",
  "properties": {
    "datasets": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiDataset"
      },
      "description": "List of datasets that are requested to be added."
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  },
  "description": "Request to add one or more datasets."
}

{
  "type": "object",
  "title": "Evaluate this model vesion",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "evalMetrics": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiEvalMetrics"
      },
      "description": "eval_info, id, model, and ground_truth_dataset will be used when creating the evaluation\nIf no dataset is provided, all app data that is annotated with concepts from the model will be used."
    }
  }
}

{
  "type": "object",
  "properties": {
    "appPat": {
      "type": "string",
      "title": "Personal Access Token to the application to which inputs are added"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "callBackUrl": {
      "type": "string",
      "description": "If call back url is set, we will send a Post request to this endpoint with job status."
    },
    "dataSources": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiInputsDataSource"
      }
    }
  },
  "description": "Initiates retrieval of inputs from cloud storage from a user provided data source.\nWill create and return an inputs-add-job for tracking progress.\nArchives will be extracted and their contents will be processed as inputs.\n\nThe cloud URL will be treated as a filter prefix. For example s3:/bucket/images_folder/abc will process\nfiles in the images_folder beginning with abc or in a subfolder beginning with abc.\nFor example:\nbucket/images_folder/abcImage.png\nbucket/images_folder/abc-1/Data.zip\n\nIf given URL is for a private bucket or file, then credentials should be provided to access the bucket.\nCredentials should include rights to list the objects in the bucket, except when pointed directly at a file archive,\nin which case it only requires rights to access that particular file."
}

{
  "type": "object",
  "title": "PostInputsRequest",
  "properties": {
    "inputs": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiInput"
      },
      "title": "List of inputs to post.\nFor each input, the following fields are used:\n* id\n* data\n* dataset_ids"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "inputsAddJobId": {
      "type": "string",
      "description": "Collect statistics about created inputs in job with given ID.\n* If job ID is empty, then job is not created.\n* If job ID is non-empty and doesn't already exist, then a new job will be created with given ID.\n* If job ID does already exist, then new inputs statistics are merged with previous inputs statistics."
    },
    "inputIdConflictResolution": {
      "$ref": "#/components/schemas/apiInputIDConflictResolution"
    }
  }
}

{
  "type": "object",
  "title": "Execute a new input search and optionally save it",
  "properties": {
    "searches": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiSearch"
      },
      "title": "The searched to be executed or saved"
    },
    "onlyCount": {
      "type": "boolean",
      "description": "If only_count is set, then the response will not contain hits,\nbut hit_counts instead."
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "pagination": {
      "$ref": "#/components/schemas/apiPagination"
    }
  }
}

{
  "type": "object",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "inputsUploads": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiInputsUpload"
      }
    }
  },
  "description": "Start uploading a file archive containing inputs.\nWill create and return an inputs-add-job for tracking progress.\n\nAssociated inputs-add-job contains an upload id which should be completed through `PutUploadContentParts` endpoint.\nCompleting the upload will automatically begin unpacking the archive and uploading the contents as inputs."
}

{
  "type": "object",
  "title": "POST new knowledge graphs",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "knowledgeGraphs": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiKnowledgeGraph"
      }
    }
  }
}

{
  "type": "object",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "labelOrders": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiLabelOrder"
      }
    }
  },
  "description": "Request to create label orders."
}

{
  "type": "object",
  "properties": {
    "model": {
      "$ref": "#/components/schemas/apiModel"
    },
    "inputs": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiInput"
      }
    },
    "modelId": {
      "type": "string"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "versionId": {
      "type": "string"
    },
    "runnerSelector": {
      "$ref": "#/components/schemas/apiRunnerSelector"
    }
  },
  "description": "//////////////////////////////////////////////////\nModel prediction related stuff needs inputs and produces outputs.\n//////////////////////////////////////////////////\nModel prediction."
}

{
  "type": "object",
  "properties": {
    "modelId": {
      "type": "string",
      "title": "model to create version of"
    },
    "totalSize": {
      "type": "string",
      "title": "number of bytes in the model files to be uploaded",
      "format": "uint64"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "modelVersion": {
      "$ref": "#/components/schemas/apiModelVersion"
    }
  }
}

{
  "type": "object",
  "properties": {
    "contentPart": {
      "$ref": "#/components/schemas/apiUploadContentPart"
    },
    "uploadConfig": {
      "$ref": "#/components/schemas/apiPostModelVersionsUploadConfig"
    }
  }
}

{
  "type": "object",
  "properties": {
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "bytesRemaining": {
      "type": "string",
      "format": "uint64"
    },
    "modelVersionId": {
      "type": "string",
      "title": "ID of the model version being uploaded"
    }
  }
}

{
  "type": "object",
  "title": "PostModelsRequest",
  "properties": {
    "model": {
      "$ref": "#/components/schemas/apiModel"
    },
    "models": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiModel"
      },
      "description": "This allows you to create one or more model by posting it to the API."
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  }
}

{
  "type": "object",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "modelQuery": {
      "$ref": "#/components/schemas/apiModelQuery"
    },
    "pagination": {
      "$ref": "#/components/schemas/apiPagination"
    }
  },
  "description": "Search over the available models."
}

{
  "type": "object",
  "title": "PostSearchesRequest",
  "properties": {
    "query": {
      "$ref": "#/components/schemas/apiQuery"
    },
    "searches": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiSearch"
      },
      "title": "The searched to be executed or saved\nEventually the request level fields will be deprecated in favor of this object"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "pagination": {
      "$ref": "#/components/schemas/apiPagination"
    }
  }
}

{
  "type": "object",
  "title": "PostStatValuesAggregateRequest",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "statValueAggregateQueries": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiStatValueAggregateQuery"
      },
      "description": "Query to retrieve aggregate values."
    }
  }
}

{
  "type": "object",
  "title": "PostStatValuesRequest",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "statValues": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiStatValue"
      },
      "description": "The stats to post, can post more than one at a time."
    }
  }
}

{
  "type": "object",
  "properties": {
    "tasks": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiTask"
      }
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  },
  "description": "Request to create Tasks."
}

{
  "type": "object",
  "title": "Start a multipart upload",
  "properties": {
    "uploads": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiUpload"
      }
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  }
}

{
  "type": "object",
  "title": "PostValidatePasswordRequest",
  "properties": {
    "password": {
      "$ref": "#/components/schemas/apiPassword"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  }
}

{
  "type": "object",
  "title": "PostWorkflowResultsResponse",
  "properties": {
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiWorkflowResult"
      },
      "description": "The resulting predictions of all models in the workflow."
    },
    "workflow": {
      "$ref": "#/components/schemas/apiWorkflow"
    },
    "workflowState": {
      "$ref": "#/components/schemas/apiWorkflowState"
    }
  }
}

{
  "type": "object",
  "title": "PostWorkflowResultsSimilarityResponse",
  "properties": {
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiWorkflowResultsSimilarity"
      }
    }
  }
}

{
  "type": "object",
  "title": "PostWorkflowsRequest",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "workflows": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiWorkflow"
      }
    }
  }
}

{
  "type": "object",
  "title": "PrecisionRecallCurve",
  "properties": {
    "recall": {
      "type": "array",
      "items": {
        "type": "number",
        "format": "float"
      }
    },
    "precision": {
      "type": "array",
      "items": {
        "type": "number",
        "format": "float"
      }
    },
    "thresholds": {
      "type": "array",
      "items": {
        "type": "number",
        "format": "float"
      }
    }
  }
}

{
  "type": "object",
  "title": "PretrainedModelConfig",
  "properties": {
    "modelZipUrl": {
      "type": "string",
      "title": "Url to a zipped up model in triton format with the following files and folders at the root:\n config.pbtxt\n version 1 folder that contains model files (onnx graph, torch script, python BE model, and etc.)",
      "description": "Whether to overwrite the model for the existing internal id"
    },
    "inputFieldsMap": {
      "type": "object",
      "description": "This is the internal id of the pretrained model.\nMap from the api.Data field names to the Triton config.pbtxt input."
    },
    "outputFieldsMap": {
      "type": "object",
      "description": "Map from the api.Data field names to the Triton config.pbtxt output."
    }
  }
}

{
  "type": "object",
  "title": "Processing info tells the runner how to process a RunnerItem",
  "properties": {
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "runnerMethodType": {
      "$ref": "#/components/schemas/apiRunnerMethodType"
    }
  }
}

{
  "type": "object",
  "properties": {
    "processed": {
      "type": "integer",
      "format": "int64"
    },
    "lastProcessedId": {
      "type": "string"
    }
  }
}

{
  "enum": [
    "PUT_TASK_ASSIGNMENTS_REQUEST_ACTION_NOT_SET",
    "LABEL_START",
    "LABEL_SUBMIT",
    "REVIEW_START",
    "REVIEW_APPROVE",
    "REVIEW_REQUEST_CHANGES"
  ],
  "type": "string",
  "title": "- LABEL_START: Create a list of task assignments for labeler => 10 inputs are assigned to the labeler.\nThis is a fully sync action.\nIf task assignments already exist, then return existing task assignments.\n - LABEL_SUBMIT: Submit task assignments => mark task assignment work as completed.\nThis is a partially sync action.\nSync: task assignments are updated as follows:\n* when review_strategy is NONE, then task assignment status is updated to SUCCESS.\n* when review strategy is CONSENSUS, then task assignment status is updated to AWAITING_CONSENSUS_REVIEW.\n* when review strategy is MANUAL, then task assignment status is updated to AWAITING_REVIEW.\nIf task assignments are already submitted, then no update is performed on them.\nAsync: annotations added for the same input as the task assignment are updated as follows:\n* when review_strategy is NONE, then annotation status is updated to SUCCESS.\n* when review strategy is CONSENSUS, then annotation status is updated to SUCCESS (if it reaches consensus) or AWAITING_REVIEW (if it does not reach consensus).\n* when review strategy is MANUAL, then annotation status is updated to AWAITING_REVIEW.\n - REVIEW_START: Return a list of task assignments for reviewer to review => 10 inputs are assigned to the reviewer.\nThis is a fully sync action.\nNOT idempotent:\n In the current implementation, we don't actually store the reviewer in the task assignment,\n as the task assignment still stays assigned to the labeler.\n Therefore, multiple calls to this endpoint may result in different set of task assignments to review.\n For now, this action is practically not idempotent.\n In the future, we could however store the reviewer in the task assignment and\n return existing task assignments already assigned to the reviewer => this will make this action idempotent.\n - REVIEW_APPROVE: Approve task assignments.\nThere are two types of configurations:\n* Batch approve: approve a list of task assignment IDs;\n* Bulk approve: approve all task assignments from a list of workers.\nThis is a partially sync action.\nSync: task assignments are updated to SUCCESS\nAsync: annotations added for the same input as the task assignment are updated to SUCCESS\n - REVIEW_REQUEST_CHANGES: Request changes for task assignments.\nThere are two types of configurations:\n* Batch request changes: request changes for a list of task assignment IDs;\n* Bulk request changes: request changes for all task assignments from a list of workers.\nThis is a partially sync action.\nSync: task assignments are updated to PENDING\nAsync: annotations added for the same input as the task assignment are updated to PENDING",
  "default": "PUT_TASK_ASSIGNMENTS_REQUEST_ACTION_NOT_SET"
}

{
  "type": "object",
  "properties": {
    "ands": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiAnd"
      },
      "description": "The query syntax is simply a list of And operatiosn that will be ANDed together to fetch\nresults which are returned to the user as Hit messages.\n\nDeprecated: Only used by the deprecated PostSearches endpoint. Use filters\nand ranks instead with PostInputsSearches or PostAnnotationsSearches."
    },
    "ranks": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiRank"
      },
      "title": "rankings in this query\ne.g. visual search by a url"
    },
    "filters": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiFilter"
      },
      "title": "filters in this query\ne.q. only fetch annotations that have certain metadata"
    },
    "language": {
      "type": "string",
      "description": "This allows the query to override any default language the app was setup in when doing Concept\nbased searches. This currently only affects public Models Output searches when those public\nModels have translations for their Concepts."
    }
  },
  "description": "This is the search query used in /searches, model training requests, bulk data exports, etc."
}

{
  "type": "object",
  "title": "ROC",
  "properties": {
    "fpr": {
      "type": "array",
      "items": {
        "type": "number",
        "format": "float"
      }
    },
    "tpr": {
      "type": "array",
      "items": {
        "type": "number",
        "format": "float"
      }
    },
    "thresholds": {
      "type": "array",
      "items": {
        "type": "number",
        "format": "float"
      }
    },
    "fprPerImage": {
      "type": "array",
      "items": {
        "type": "number",
        "format": "float"
      }
    },
    "fprPerObject": {
      "type": "array",
      "items": {
        "type": "number",
        "format": "float"
      }
    }
  }
}

{
  "type": "object",
  "title": "Rank",
  "properties": {
    "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"
    },
    "annotation": {
      "$ref": "#/components/schemas/clarifaiapiAnnotation"
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "A unique id for the region."
    },
    "data": {
      "$ref": "#/components/schemas/apiData"
    },
    "value": {
      "type": "number",
      "format": "float",
      "description": "This is the confidence score of the overall Region."
    },
    "trackId": {
      "type": "string",
      "description": "For tracking algorithsm and annotations we tie regions together with this track id."
    },
    "regionInfo": {
      "$ref": "#/components/schemas/apiRegionInfo"
    }
  },
  "description": "A region within the data."
}

{
  "type": "object",
  "properties": {
    "mask": {
      "$ref": "#/components/schemas/apiMask"
    },
    "span": {
      "$ref": "#/components/schemas/apiSpan"
    },
    "point": {
      "$ref": "#/components/schemas/apiPoint"
    },
    "token": {
      "$ref": "#/components/schemas/apiToken"
    },
    "polygon": {
      "$ref": "#/components/schemas/apiPolygon"
    },
    "boundingBox": {
      "$ref": "#/components/schemas/apiBoundingBox"
    },
    "keypointLocations": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiPoint"
      },
      "description": "The locations of detected keypoints, which are to be used in conjunction with the detected concept's skeleton to connect the keypoint locations.\nThese will be in the same order as the respective keypoint_names inside the concept."
    }
  },
  "description": "The information of the location of the Region."
}

{
  "type": "object",
  "properties": {
    "workers": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiWorker"
      }
    },
    "taskAssignments": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiTaskAssignment"
      }
    }
  }
}

{
  "type": "object",
  "properties": {
    "workers": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiWorker"
      }
    },
    "taskAssignments": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiTaskAssignment"
      }
    }
  }
}

{
  "type": "object",
  "title": "A worker for compute within a nodepool of instances.\nThis asks the API for work",
  "properties": {
    "id": {
      "type": "string",
      "description": "A unique ID for this app module.\nThis is a UUID since runners can be automatically orchestrated."
    },
    "model": {
      "$ref": "#/components/schemas/apiModel"
    },
    "labels": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Labels to match in order to find work."
    },
    "userId": {
      "type": "string",
      "description": "The owner of the runner. Runners belong to a user/org account."
    },
    "metadata": {
      "type": "object",
      "description": "To handle arbitrary json metadata you can use a struct field:\nhttps://github.com/google/protobuf/blob/master/src/google/protobuf/struct.proto\nThis is an optional arg."
    },
    "nodepool": {
      "$ref": "#/components/schemas/apiNodepool"
    },
    "workflow": {
      "$ref": "#/components/schemas/apiWorkflow"
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the app module was created."
    },
    "modifiedAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the app module was last modified."
    },
    "computeInfo": {
      "$ref": "#/components/schemas/apiComputeInfo"
    },
    "description": {
      "type": "string",
      "description": "A short description for this app module to be used in grids of modules."
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "A UUID hash for this work item."
    },
    "description": {
      "type": "string",
      "description": "A description of the work to be done in case needed for UIs."
    },
    "processingInfo": {
      "$ref": "#/components/schemas/apiProcessingInfo"
    },
    "postModelOutputsRequest": {
      "$ref": "#/components/schemas/apiPostModelOutputsRequest"
    }
  },
  "description": "This is a piece of work for a runner to process."
}

{
  "type": "object",
  "properties": {
    "multiOutputResponse": {
      "$ref": "#/components/schemas/apiMultiOutputResponse"
    }
  }
}

{
  "enum": [
    "UNKNOWN",
    "UNARY_UNARY",
    "UNARY_STREAMING",
    "STREAMING_UNARY",
    "STREAMING_STREAMING"
  ],
  "type": "string",
  "title": "- UNARY_UNARY: single request, single response. predict() in code\n - UNARY_STREAMING: single request, streamed response. generate() in code\n - STREAMING_UNARY: stream of requests, single response.\n - STREAMING_STREAMING: stream of requests, stream of responses. stream() in code",
  "default": "UNKNOWN"
}

{
  "type": "object",
  "properties": {
    "runner": {
      "$ref": "#/components/schemas/apiRunner"
    },
    "nodepool": {
      "$ref": "#/components/schemas/apiNodepool"
    },
    "deployment": {
      "$ref": "#/components/schemas/apiDeployment"
    }
  },
  "description": "////////////////////////////////////////\nDon't need RunnerSelector if we're opening up endpoints for deployments.\n////////////////////////////////////////\nThe RunnerSelector is an optional field we can provide during runtime\nof model/workflow predictions to specify which particular runner we want to process the work.\nThis can optionally be used to select a particular nodepool and then within that nodepool\na particular runner."
}

{
  "type": "object",
  "title": "ScopeDeps",
  "properties": {
    "scope": {
      "type": "string",
      "title": "The scope"
    },
    "dependingScopes": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Other scopes that are required."
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "Customer facing, external ID for search to be saved. Provided by the user, e.g. \"saved-search-1.\nIt is unique per application."
    },
    "asOf": {
      "type": "string",
      "format": "date-time",
      "description": "\"As of\" timestamp, indicating a time in the past as of which we want to\nretrieve the annotations satisfying the query."
    },
    "name": {
      "type": "string",
      "description": "Human readable display name of the saved search."
    },
    "save": {
      "type": "boolean",
      "title": "If true, save this search, and exit without executing the search.\nIf false execute the query"
    },
    "query": {
      "$ref": "#/components/schemas/apiQuery"
    },
    "metric": {
      "$ref": "#/components/schemas/SearchMetric"
    },
    "gitHash": {
      "type": "string",
      "description": "Git hash of the code that ran the filter."
    },
    "minValue": {
      "type": "number",
      "format": "float",
      "description": "Minimum value of confidence threshold score in result.\nDefaults to 0.0 which means we won't do any thresholding as all probabilities will\nlikely be > 0.0."
    },
    "algorithm": {
      "type": "string",
      "title": "The search algorithm to be used.\nOptions are are 'nearest_neighbor', 'brute_force', and 'avg_concept_brute_force'\nThe last two perform a brute force search visual search instead of a more scalable distributed\nnearest neighbor search and should be used by advanced users only.\nIf not specified we default to nearest neighbor"
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the saved search was created."
    },
    "modifiedAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the saved search was updated."
    },
    "visibility": {
      "$ref": "#/components/schemas/clarifaiapiVisibility"
    },
    "applicationId": {
      "type": "string",
      "description": "Application that owns this saved search."
    }
  },
  "description": "This is the new Search object used in saved searches."
}

{
  "type": "object",
  "title": "SingleAnnotationFilterResponse",
  "properties": {
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "annotationFilter": {
      "$ref": "#/components/schemas/apiAnnotationFilter"
    }
  }
}

{
  "type": "object",
  "title": "SingleAnnotationResponse",
  "properties": {
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "annotation": {
      "$ref": "#/components/schemas/clarifaiapiAnnotation"
    }
  }
}

{
  "type": "object",
  "title": "SingleAppDuplicationResponse",
  "properties": {
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "appDuplication": {
      "$ref": "#/components/schemas/apiAppDuplication"
    }
  }
}

{
  "type": "object",
  "title": "SingleAppResponse",
  "properties": {
    "app": {
      "$ref": "#/components/schemas/apiApp"
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    }
  }
}

{
  "type": "object",
  "title": "SingleBulkOperationsResponse",
  "properties": {
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "bulkOperation": {
      "$ref": "#/components/schemas/apiBulkOperation"
    }
  }
}