{
  "type": "object",
  "properties": {
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    },
    "publications": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiWorkflowVersionUnPublishRequest"
      }
    }
  }
}

{
  "type": "object",
  "properties": {
    "userAppId": {
      "type": "object",
      "description": "Common message to identify the app in a url endpoint."
    },
    "publications": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiWorkflowVersionUnPublishRequest"
      }
    }
  }
}

{
  "type": "object",
  "title": "PostWorkflowsRequest",
  "properties": {
    "userAppId": {
      "type": "object",
      "description": "Common message to identify the app in a url endpoint."
    },
    "workflows": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiWorkflow"
      }
    }
  }
}

{
  "type": "object",
  "properties": {
    "exports": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiDatasetVersionExport"
      },
      "description": "exports is the list of requested dataset version exports.\nOnly setting the 'format' field of the export is supported."
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  },
  "description": "Request to create exports of a dataset version."
}

{
  "type": "object",
  "properties": {
    "exports": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiDatasetVersionExport"
      },
      "description": "exports is the list of requested dataset version exports.\nOnly setting the 'format' field of the export is supported."
    },
    "userAppId": {
      "type": "object",
      "description": "Common message to identify the app in a url endpoint."
    }
  },
  "description": "Request to create exports of a dataset version."
}

{
  "type": "object",
  "title": "PutTaskAssignmentsRequest",
  "properties": {
    "action": {
      "$ref": "#/components/schemas/apiPutTaskAssignmentsRequestAction"
    },
    "inputId": {
      "type": "string",
      "title": "Deprecated: use action and action_config instead.\nSupported for backwards compatibility: setting this field is equivalent with\n* action = LABEL_SUBMIT\n* label_submit_config = [{\"task_assignments\": {\"input\": {\"id\": <input-id>}}}]"
    },
    "userAppId": {
      "type": "object",
      "description": "Common message to identify the app in a url endpoint."
    },
    "labelSubmitConfig": {
      "$ref": "#/components/schemas/apiLabelSubmitConfig"
    },
    "reviewApproveConfig": {
      "$ref": "#/components/schemas/apiReviewApproveConfig"
    },
    "reviewRequestChangesConfig": {
      "$ref": "#/components/schemas/apiReviewRequestChangesConfig"
    }
  }
}

{
  "type": "object",
  "properties": {
    "userAppId": {
      "type": "object",
      "description": "Common message to identify the app in a url endpoint."
    },
    "contentParts": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiUploadContentPart"
      }
    }
  },
  "description": "Upload a part of a multipart upload.\nBehaviour on completion depends on the endpoint that was used to initiate the upload."
}

{
  "enum": [
    "UNKNOWN_VISIBILITY",
    "PRIVATE",
    "ORG",
    "PUBLIC"
  ],
  "type": "string",
  "default": "UNKNOWN_VISIBILITY",
  "description": "Gettable defined the level of access for GET operations for this resource.\n\n - UNKNOWN_VISIBILITY: Default value not allowed.\n - PRIVATE: PRIVATE requires collaborator or team permissions in order to GET this resource.\n - ORG: ORG requires you to be in the same org in order to GET this resource, but don't have to be a\nteammate or collaborator.\n - PUBLIC: PUBLIC opens up GET access to the resource to any user on the platform even if they are not\na teammate or collaborator."
}

{
  "type": "object",
  "properties": {
    "modelId": {
      "type": "string",
      "description": "The Model ID of the model we want to collect from."
    },
    "modelAppId": {
      "type": "string",
      "description": "The App ID of the model we want to collect from."
    },
    "modelUserId": {
      "type": "string",
      "description": "To define the model that we should collect from we need to specify the following 4 IDs:\nThe User ID of the model we want to collect from.\nThis is User B in the example."
    },
    "callerUserId": {
      "type": "string",
      "description": "This is a private field that defaults to the app owner for public users.\nIf this is left blank then this collector will collect from ALL users calling the given model."
    },
    "modelVersionId": {
      "type": "string",
      "description": "The Version ID of the model we want to collect from."
    },
    "postInputsKeyId": {
      "type": "string",
      "description": "This key is used to POST /inputs into your app by the collector. It can be an API key or a\nPAT. This needs the permissions that are needed for POST /inputs for the app_id this\nCollector is defined in."
    }
  },
  "description": "This is configuration for using the inputs send for model prediction in our API as\nas the source for data."
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string"
    },
    "token": {
      "type": "string"
    },
    "region": {
      "type": "string"
    },
    "secret": {
      "type": "string"
    }
  },
  "description": "AWS S3 storage credentials."
}

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

{
  "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": {
    "datasetId": {
      "type": "string"
    }
  }
}

{
  "type": "object",
  "title": "AiAssistParameters",
  "properties": {
    "maxThreshold": {
      "type": "number",
      "format": "float"
    },
    "minThreshold": {
      "type": "number",
      "title": "Min and max threshold values for approving annotations by default based on prediction score",
      "format": "float"
    },
    "conceptRelationIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "ids of concept relations. Used in AI assist workflow"
    }
  }
}

{
  "type": "object",
  "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\"}"
    },
    "output": {
      "$ref": "#/components/schemas/apiOutput"
    },
    "annotation": {
      "$ref": "#/components/schemas/clarifaiapiAnnotation"
    }
  },
  "description": "This is the common building block of a query which is a sequence of And messages ANDed together.\nNote that some fields are used too RANK results (affect the scores) and some are used to FILTER\nresults (unordered subset of your app's contents). In general, FILTER operations are more\nefficient queries at scale and when combined with RANK operations can speed up search performance\nas you effectively operate on a smaller sub-set of your entire app."
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "title": "The ID for the annotation filter"
    },
    "appId": {
      "type": "string",
      "description": "The app the annotation filter belongs to."
    },
    "search": {
      "$ref": "#/components/schemas/apiSearch"
    },
    "userId": {
      "type": "string",
      "description": "The user the annotation filter belongs to."
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the annotation filter was created.\nThe format is https://www.ietf.org/rfc/rfc3339.txt.\nExample: \"2006-01-02T15:04:05.999999Z\"."
    },
    "modifiedAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the annotation filter was modified.\nThe format is https://www.ietf.org/rfc/rfc3339.txt.\nExample: \"2006-01-02T15:04:05.999999Z\"."
    }
  },
  "description": "AnnotationFilter is used to create a new dataset version.\nFor now, the filter is simply a wrapper over a Search.\nIn the future, we may add extra fields to customize the filtering."
}

{
  "type": "object",
  "properties": {
    "annotationFilter": {
      "$ref": "#/components/schemas/apiAnnotationFilter"
    },
    "ignoreEmptyInputs": {
      "type": "boolean",
      "description": "If true, empty inputs are not included in the dataset version.\nIf false, empty inputs are included in the dataset version.\nWe define an empty input as an input without any annotations after annotation filter is applied."
    }
  }
}

{
  "type": "object",
  "title": "AnnotationSearchMetrics",
  "properties": {
    "data": {
      "$ref": "#/components/schemas/apiData"
    },
    "metrics": {
      "$ref": "#/components/schemas/apiEvalMetrics"
    },
    "visibility": {
      "$ref": "#/components/schemas/clarifaiapiVisibility"
    },
    "groundTruth": {
      "$ref": "#/components/schemas/apiSearch"
    },
    "searchToEval": {
      "$ref": "#/components/schemas/apiSearch"
    },
    "activeConceptCount": {
      "type": "integer",
      "title": "active_concept_count is the number of concepts for this evaluation",
      "format": "int64"
    }
  }
}

{
  "type": "object",
  "title": "Application with tasks and datasets",
  "properties": {
    "id": {
      "type": "string"
    },
    "name": {
      "type": "string"
    },
    "image": {
      "$ref": "#/components/schemas/apiImage"
    },
    "notes": {
      "type": "string",
      "description": "Notes for the application\nThis field should be used for in-depth notes and supports up to 64Kbs."
    },
    "userId": {
      "type": "string",
      "title": "why is user_id present here when this message type is used in PostApps but completely ignored there? PostApp already\nspecifies the userid in path but doesn't even actually use neither of userids, it instead used the id from auth context.\nThis creates a lot of ambiguity, should always have different message types for Post/Get endpoints so that the minimum interface for each op can be described"
    },
    "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"
    },
    "sampleMs": {
      "type": "integer",
      "title": "Default value for model predictions on video: Sample delay for video predicting (1 frame per N milliseconds)",
      "format": "int64"
    },
    "createdAt": {
      "type": "string",
      "title": "When the app was created. We follow the XXXX timestamp\nformat. We use https://www.ietf.org/rfc/rfc3339.txt format:\n\"2006-01-02T15:04:05.999999Z\" so you can expect results like\nthe following from the API:\n\"2017-04-11T21:50:50.223962Z\"",
      "format": "date-time"
    },
    "extraInfo": {
      "$ref": "#/components/schemas/apiAppExtraInfo"
    },
    "isStarred": {
      "type": "boolean",
      "title": "Is starred by the requesting user (only showed on get/list requests)\nPlease use PostAppStars/DeleteAppStars endpoints to star/unstar an app"
    },
    "starCount": {
      "type": "integer",
      "title": "How many users have starred the app (only showed on get/list requests)\nComputed value, not editable",
      "format": "int32"
    },
    "dataTierId": {
      "type": "string",
      "description": "data tier id this app is using."
    },
    "isTemplate": {
      "type": "boolean",
      "description": "An app marked as a template can be duplicated by any user that can see it,\nincluding all visible resources within it."
    },
    "modifiedAt": {
      "type": "string",
      "title": "When the app was last modified",
      "format": "date-time"
    },
    "visibility": {
      "$ref": "#/components/schemas/clarifaiapiVisibility"
    },
    "description": {
      "type": "string",
      "description": "short description about the app."
    },
    "defaultLanguage": {
      "type": "string"
    },
    "defaultWorkflow": {
      "$ref": "#/components/schemas/apiWorkflow"
    },
    "defaultWorkflowId": {
      "type": "string",
      "title": "Default workflow id deprecated in favor of default_workflow"
    },
    "legalConsentStatus": {
      "type": "integer",
      "title": "if user accept legal consent for face recognition",
      "format": "int64"
    }
  }
}

{
  "type": "object",
  "properties": {
    "field": {
      "type": "string"
    },
    "value": {
      "type": "integer",
      "format": "int32"
    }
  }
}

{
  "type": "object",
  "title": "AppDuplication",
  "properties": {
    "id": {
      "type": "string",
      "description": "The unique identifier of an app duplication job."
    },
    "filter": {
      "$ref": "#/components/schemas/apiAppDuplicationFilters"
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "newAppId": {
      "type": "string",
      "description": "The ID to use when creating a new application.\nYou cannot set this field when copying into an existing app, i.e., when existing_app_is is set.\n\nIf not provided, then it will be generated automatically.\n\nDeprecated: Use destination_app.id with a new ID instead."
    },
    "progress": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiAppCopyProgress"
      },
      "title": "Copy progress for each resource type requested by the filter. Possible fields:\n - inputs\n - concepts\n - annotations\n - models\n - workflows\n - installed_module_versions"
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "The time when the app duplication job was created."
    },
    "newAppName": {
      "type": "string",
      "description": "The name to use when creating a new application.\nYou cannot set this field when copying into an existing app, i.e., when existing_app_is is set.\n\nIf not provided, then the ID of the new application is also used as the name.\n\nDeprecated: Application names are deprecated, use application IDs instead."
    },
    "existingAppId": {
      "type": "string",
      "description": "The ID of an existing app you want to copy data into.\n\nIf not provided, then we will create a new application as the destination instead.\nThe various new_app_* fields can be used to set fields of this new application.\n\nDeprecated: Use destination_app.id with an existing ID instead."
    },
    "destinationApp": {
      "$ref": "#/components/schemas/apiApp"
    },
    "lastModifiedAt": {
      "type": "string",
      "format": "date-time",
      "description": "The last time when the app duplication job status was updated."
    }
  }
}

{
  "type": "object",
  "title": "AppDuplicationFilters",
  "properties": {
    "copyInputs": {
      "type": "boolean",
      "description": "Copy inputs. Requires that copy_concepts is also set.\nNote that this will still copy input-level annotations even if copy_annotations is not set."
    },
    "copyModels": {
      "type": "boolean",
      "description": "Copy models. Requires that copy_concepts is also set."
    },
    "copyConcepts": {
      "type": "boolean",
      "description": "Copy concepts."
    },
    "copyWorkflows": {
      "type": "boolean",
      "description": "Copy workflows. Requires that copy_models and copy_concepts are also set."
    },
    "copyAnnotations": {
      "type": "boolean",
      "description": "Copy annotations. Requires that copy_inputs and copy_concepts are also set."
    },
    "copyInstalledModuleVersions": {
      "type": "boolean",
      "description": "Copy installed module versions."
    }
  }
}

{
  "type": "object",
  "properties": {
    "searchRevisionMarker": {
      "type": "string",
      "title": "Revision marker for this application.\nThe value of the revision changes when\n* inputs are added, updated or deleted\n* annotations are added, updated or deleted\n* inputs are added to or removed from datasets\nFor example, this value can be used to detect if client side caches related to searching should be invalidated.\nField not filled in for list endpoints, use GetApp"
    }
  }
}

{
  "type": "object",
  "title": "App query",
  "properties": {
    "name": {
      "type": "string",
      "description": "Query by application name. This supports wildcard queries like \"gen*\" to match \"general\" as an example."
    }
  }
}

{
  "type": "object",
  "title": "Audio asset struct",
  "properties": {
    "url": {
      "type": "string",
      "description": "This is a URL to a publicly accessible image file. The platform will download this file server\nside and then process."
    },
    "base64": {
      "type": "string",
      "format": "byte",
      "description": "The base64 field is using image file bytes directly in the request.\nNOTE: if you're sending a json request, then this MUST be base64 encoded before sending (hence\nthe name here).\nWhen using our grpc clients, you DO NOT need to base64 encode\nit yourself since the clients know how to do this for you automatically and will avoid the\nbase64 encoding if they send a binary request."
    },
    "hosted": {
      "$ref": "#/components/schemas/apiHostedURL"
    },
    "audioInfo": {
      "$ref": "#/components/schemas/apiAudioInfo"
    },
    "allowDuplicateUrl": {
      "type": "boolean",
      "description": "If True then you will be allowed to have multiple urls."
    }
  }
}

{
  "type": "object",
  "properties": {
    "bitRate": {
      "type": "integer",
      "title": "audio track bit rate",
      "format": "int32"
    },
    "sampleRate": {
      "type": "integer",
      "title": "sample rate",
      "format": "int32"
    },
    "audioFormat": {
      "type": "string",
      "title": "audio format"
    },
    "durationSeconds": {
      "type": "number",
      "title": "audio track duration in seconds",
      "format": "float"
    }
  }
}

{
  "type": "object",
  "properties": {
    "maxReplicas": {
      "type": "integer",
      "format": "int64",
      "description": "The maximium number of replicas to scale up the runner to."
    },
    "minReplicas": {
      "type": "integer",
      "format": "int64",
      "description": "The minimum number of replicas for the runner to have.\nDefaults to 0 which means autoscaling can scale down to zero.\nIf you want a replica always up then set to >= 1."
    },
    "enablePacking": {
      "type": "boolean",
      "description": "Depending on your plan you may be able to enable packing of resources into a single node\nfor more compute and cost efficiency."
    },
    "scaleUpDelaySeconds": {
      "type": "integer",
      "format": "int64",
      "description": "The time to wait between scaling up replicas without burst traffic."
    },
    "scaleDownDelaySeconds": {
      "type": "integer",
      "format": "int64",
      "description": "The time to wait before scaling down after the last request."
    },
    "trafficHistorySeconds": {
      "type": "integer",
      "format": "int64",
      "description": "The number of seconds of traffic history to consider when autoscaling."
    }
  },
  "description": "It might be better to do this as runner autoscaling so that resources\nof a model are very simply what that model needs at minimum.\nNote that resources for things like modes inside runners are not\nrelated to how many replicas of those runners are needed to handle traffic."
}

{
  "type": "object",
  "properties": {
    "accountKey": {
      "type": "string"
    },
    "accountName": {
      "type": "string"
    }
  },
  "description": "Azure Blob storage credentials."
}

{
  "type": "object",
  "title": "BinaryMetrics",
  "properties": {
    "f1": {
      "type": "number",
      "format": "float"
    },
    "iou": {
      "type": "number",
      "format": "float"
    },
    "numNeg": {
      "type": "integer",
      "format": "int64"
    },
    "numPos": {
      "type": "integer",
      "format": "int64"
    },
    "numTot": {
      "type": "integer",
      "format": "int64"
    },
    "rocAuc": {
      "type": "number",
      "format": "float"
    },
    "areaMax": {
      "type": "number",
      "format": "double"
    },
    "areaMin": {
      "type": "number",
      "format": "double"
    },
    "concept": {
      "$ref": "#/components/schemas/apiConcept"
    },
    "areaName": {
      "type": "string"
    },
    "rocCurve": {
      "$ref": "#/components/schemas/apiROC"
    },
    "avgPrecision": {
      "type": "number",
      "format": "float"
    },
    "precisionRecallCurve": {
      "$ref": "#/components/schemas/apiPrecisionRecallCurve"
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "title": "original resource id"
    },
    "appId": {
      "type": "string",
      "title": "original resource app id"
    },
    "userId": {
      "type": "string",
      "title": "original resource user id"
    },
    "resourceType": {
      "$ref": "#/components/schemas/BookmarkOriginBookmarkType"
    }
  }
}

{
  "type": "object",
  "properties": {
    "topRow": {
      "type": "number",
      "title": "The top left of the bounding box normalized to the data dimension to be within [0-1.0]",
      "format": "float"
    },
    "leftCol": {
      "type": "number",
      "title": "The left column of the bounding box normalized to the data dimension to be within [0-1.0]",
      "format": "float"
    },
    "rightCol": {
      "type": "number",
      "title": "The right col of the bounding box normalized to the data dimension to be within [0-1.0]",
      "format": "float"
    },
    "bottomRow": {
      "type": "number",
      "title": "The bottom row of the bounding box normalized to the data dimension to be within [0-1.0]",
      "format": "float"
    }
  },
  "description": "Rectangular bounding box for a region."
}

{
  "type": "object",
  "properties": {
    "dockerImageTag": {
      "type": "string",
      "title": "Docker image tag"
    },
    "dockerImageName": {
      "type": "string",
      "title": "Docker image name"
    },
    "dockerImageDigest": {
      "type": "string",
      "title": "Docker image digest"
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "title": "id of the Bulk Operation task"
    },
    "appId": {
      "type": "string",
      "title": "Application ID that this Operation was created from"
    },
    "search": {
      "$ref": "#/components/schemas/apiSearch"
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "dataset": {
      "$ref": "#/components/schemas/apiDataset"
    },
    "inputIds": {
      "$ref": "#/components/schemas/apiInputIDs"
    },
    "progress": {
      "$ref": "#/components/schemas/apiProgress"
    },
    "createdAt": {
      "type": "string",
      "title": "When the operation was created. We follow the XXXX timestamp\nformat. We use https://www.ietf.org/rfc/rfc3339.txt format:\n\"2006-01-02T15:04:05.999999Z\" so you can expect results like\nthe following from the API:\n\"2017-04-11T21:50:50.223962Z\"",
      "format": "date-time"
    },
    "createdBy": {
      "type": "string",
      "title": "User id that created this operation"
    },
    "operation": {
      "$ref": "#/components/schemas/apiOperation"
    },
    "lastModifiedAt": {
      "type": "string",
      "title": "Last time the status got updated",
      "format": "date-time"
    }
  }
}

{
  "type": "object",
  "title": "Cancel a list of bulk operation ids",
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "List of bulk operation ids to be cancelled"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  }
}

{
  "type": "object",
  "title": "Cancel a list of extraction job ids",
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "List of extraction job ids to be cancelled"
    },
    "userAppId": {
      "$ref": "#/components/schemas/apiUserAppIDSet"
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string"
    },
    "cloud": {
      "$ref": "#/components/schemas/CloudRegionCloud"
    },
    "region": {
      "type": "string",
      "description": "The region. The naming here depends on the cloud choice above and will be validated\nagainst which clouds+regions that Clarifai currently supports."
    }
  },
  "description": "We define a cloud region here to be used in Nodepools and by the cloud agent.\nThere will be one cloud agent per CloudRegion.\nThis allows us to define CloudRegions that are VPCs within one physical cloud and have that\nmanaged by one cloud agent which can list all nodepools for that VPC to deploy them and\norchestrate work within them."
}

{
  "type": "object",
  "title": "Cluster data",
  "properties": {
    "id": {
      "type": "string"
    },
    "hits": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiHit"
      },
      "title": "Representative hits for cluster (for now we only return 1)"
    },
    "count": {
      "type": "integer",
      "title": "Number of annotations tied to the cluster in the app",
      "format": "int64"
    },
    "score": {
      "type": "number",
      "format": "float",
      "description": "The score assigned to this cluster.\nFor List Clusters endpoint, this represents percentage of inputs in the app assigned to this cluster."
    },
    "projection": {
      "type": "array",
      "items": {
        "type": "number",
        "format": "float"
      }
    }
  }
}

{
  "type": "object",
  "properties": {
    "app": {
      "$ref": "#/components/schemas/apiApp"
    },
    "scopes": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "the low-level scope users are shared with for this collaboration"
    },
    "appOwner": {
      "$ref": "#/components/schemas/apiUser"
    },
    "createdAt": {
      "type": "string",
      "title": "when is the collaboration created",
      "format": "date-time"
    },
    "endpoints": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "the endpoint-level scopes users are shared with for this collaboration"
    }
  },
  "description": "collaboration includes an app you're invited to work on."
}

{
  "type": "object",
  "title": "Collaborator - invited user, who shares an access to an application",
  "properties": {
    "id": {
      "type": "string",
      "title": "id of this collaborator"
    },
    "app": {
      "$ref": "#/components/schemas/apiApp"
    },
    "user": {
      "$ref": "#/components/schemas/apiUser"
    },
    "scopes": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "the permission this collaborator"
    },
    "createdAt": {
      "type": "string",
      "title": "When the app was shared with. We follow the XXXX timestamp\nformat. We use https://www.ietf.org/rfc/rfc3339.txt format:\n\"2006-01-02T15:04:05.999999Z\" so you can expect results like\nthe following from the API:\n\"2017-04-11T21:50:50.223962Z\"",
      "format": "date-time"
    },
    "deletedAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the collaborator was removed from app."
    },
    "endpoints": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "modifiedAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the collaborator was updated."
    }
  }
}

{
  "type": "object",
  "title": "Collector is a data pathway from a CollectorSource to an app to collect data automatically.\nFor example, a CollectorSource",
  "properties": {
    "id": {
      "type": "string",
      "description": "Unique ID for the collector."
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "createdAt": {
      "type": "string",
      "title": "When the collector is created. We follow the XXXX timestamp\nformat. We use https://www.ietf.org/rfc/rfc3339.txt format:\n\"2006-01-02T15:04:05.999999Z\" so you can expect results like\nthe following from the API:\n\"2017-04-11T21:50:50.223962Z\"",
      "format": "date-time"
    },
    "description": {
      "type": "string",
      "description": "Human readable description for the collector."
    },
    "collectOutputs": {
      "type": "boolean",
      "description": "Whether to collect outputs or not. Default is false. If selected, outputs from the\noriginal model predict call will be posted as annotations along with the input with success status."
    },
    "collectorSource": {
      "$ref": "#/components/schemas/apiCollectorSource"
    },
    "preQueueWorkflowId": {
      "type": "string",
      "description": "This is a workflow to run inline in model predict calls. It should ONLY have very fast and\nlight-weight models in it as it will effect the speed of the predictions being made.\nThis workflow's purpose is to filter down the inputs to queue for the collector to process.\nThe input to this workflow is going to be the OUTPUT of the model, not the input to the model\nsince we want to encourage having fast workflows that can also take advantage of the model\noutputs to make deciions (for example: thresholding based on concepts). If the workflow\noutput has any field that is non-empty then the input will be queued for the collector\nto process with the post_queue_workflow_id.\n\nAs a simpler alternative, pre_queue_random_sample can be set to just use random sampling instead."
    },
    "postQueueWorkflowId": {
      "type": "string",
      "description": "A workflow to run to after the collector is processing the queued input. This workflow\nuses the original input to the model as input to the workflow so that you can run additional\nmodels as well on that input to decide whether to queue the model or not. If the workflow\noutput has any field that is non-empty then it will be passed on to POST /inputs to\nthe destination app."
    },
    "preQueueRandomSample": {
      "type": "number",
      "format": "float",
      "description": "Instead of needing to create a new workflow for pre_queue_workflow_id, if just random sampling\nof the model inputs is required, then pre_queue_random_sample can be set to a value from (0-1]\nto denote the fraction of inputs to collect."
    }
  }
}

{
  "type": "object",
  "properties": {
    "apiPostModelOutputsCollectorSource": {
      "$ref": "#/components/schemas/apiAPIPostModelOutputsCollectorSource"
    }
  },
  "description": "Configuration for the source to collect data from.\nOnly one of the fields can be present at a time.\n\nThe ID of the source in case we want to implment /collectors/{collector_id}/sources\n string id = 1;"
}

{
  "type": "object",
  "title": "Color data",
  "properties": {
    "w3c": {
      "$ref": "#/components/schemas/apiW3C"
    },
    "value": {
      "type": "number",
      "format": "float"
    },
    "rawHex": {
      "type": "string"
    }
  }
}

{
  "type": "object",
  "properties": {
    "numCpus": {
      "type": "integer",
      "format": "int64",
      "description": "Number of CPUs."
    },
    "cpuMemory": {
      "type": "string",
      "description": "Amount of CPU memory to use as a minimum."
    },
    "acceleratorType": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Or should it be removed completely and use the nodepool accelerator type itself.\nThese are the supported accelerators that the model can run on."
    },
    "numAccelerators": {
      "type": "integer",
      "format": "int64",
      "description": "Number of accelerators (typically GPUs, TPUs, etc. not CPUs) for this resource."
    },
    "acceleratorMemory": {
      "type": "string",
      "description": "Amount of accelerator/GPU memory to use as a minimum.\nThis is defined per accelerator.\nThis follows the format used by kubernetes like 1Ki, 2Mi, 3Gi, 4Ti.\n\nThe supported accelerators that the resource can run on. If the resource requires a specific\n accelerator type then it will only be scheduled on nodes that have that type of accelerator.\n If there is no hard requirements beyond the number of accelerators and their memory then this\n field can be left empty.\n This setting will cause an error if num_accelerators == 0"
    }
  },
  "description": "These are the resource needs of a given API object such as a model.\nThis is what they require as a minimum to run and will be used upon scheduling\nas the request and limit for the k8s pod. If we want to separate limits and requests in the\nfuture we can allow setting a limits ComputeInfo and a requests ComputeInfo."
}

{
  "type": "object",
  "title": "Concept or tag",
  "properties": {
    "id": {
      "type": "string",
      "description": "The concept's unique id."
    },
    "name": {
      "type": "string",
      "description": "The name of the concept in the given language."
    },
    "appId": {
      "type": "string",
      "description": "The application id that this concept is within. This can be ignored by most users."
    },
    "value": {
      "type": "number",
      "format": "float",
      "description": "Used to indicate presence (1.0) or not (0.0) of this concept when making a request.\nThis is also the prediction probability when returning predictions from our API.\nFor convenience we use the default of 1.0 when making requests so the concept you provide is\nis treated as a positive (1.0) and not a negative (which would be value == 0.0)."
    },
    "userId": {
      "type": "string",
      "description": "The user the concept belongs to."
    },
    "vocabId": {
      "type": "string",
      "description": "The vocabulary that this concept belongs to. This is useful if you have different unique sets\nof concepts that you can separate out based on this field. For example \"age_appearance\" vs\n\"gender_appearance\" in a list of concept returned from the demographics model."
    },
    "language": {
      "type": "string",
      "description": "The language in which the concept name is in. This is *ONLY* used in the response and setting\nit in a request is ignored since the default language of your app is used when creating\nor patching a Concept. To set other languages for your concept use the ConceptLanguage object\nand its corresponding endpoints."
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the concept was created. The format is https://www.ietf.org/rfc/rfc3339.txt .\nExample: \"2006-01-02T15:04:05.999999Z\". This field is used only in a response."
    },
    "extraInfo": {
      "$ref": "#/components/schemas/apiConceptExtraInfo"
    },
    "definition": {
      "type": "string",
      "description": "The definition for the concept. Similar to name. This can be ignored by most users."
    },
    "visibility": {
      "$ref": "#/components/schemas/clarifaiapiVisibility"
    },
    "keypointInfo": {
      "$ref": "#/components/schemas/apiKeypointInfo"
    }
  }
}

{
  "type": "object",
  "title": "ConceptCount",
  "properties": {
    "id": {
      "type": "string",
      "description": "The concept's unique id."
    },
    "name": {
      "type": "string",
      "description": "The name of the concept."
    },
    "conceptTypeCount": {
      "$ref": "#/components/schemas/apiConceptTypeCount"
    },
    "detailConceptCount": {
      "$ref": "#/components/schemas/apiDetailConceptCount"
    }
  }
}

{
  "type": "object",
  "properties": {
    "isRankable": {
      "type": "boolean",
      "description": "Whether this concept is rankable based on ConceptExtraInfoRequest configuration."
    }
  },
  "description": "ConceptExtraInfo represents extra information related to a concept that is context-dependent.\nIt is only set when requested in ConceptExtraInfoRequest."
}

{
  "type": "object",
  "properties": {
    "rankableModel": {
      "$ref": "#/components/schemas/apiModel"
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "This is the language code for the language such as \"en\"."
    },
    "name": {
      "type": "string",
      "description": "The type of the outside source."
    },
    "definition": {
      "type": "string",
      "description": "The ID that is referenced in the source."
    }
  },
  "description": "This represents a link to an outside source for the given concept.\nThe values from here are sticked into Concept message into the name and definition fields when\nreturning from the API in your default language. The \"id\" field here becomes the \"language\"\nfield of the Concept message which is a little weird."
}

{
  "type": "object",
  "title": "ConceptMappingJob",
  "properties": {
    "conceptIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "The ids of the concepts being mapped"
    },
    "knowledgeGraphId": {
      "type": "string",
      "title": "The id of the knowledge graph being used for this concept mapping job"
    }
  }
}

{
  "type": "object",
  "title": "ConceptQuery",
  "properties": {
    "name": {
      "type": "string",
      "description": "The name of the concept to search."
    },
    "language": {
      "type": "string",
      "description": "The language of the concept name in a search. Defaults to English."
    },
    "useCases": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiWorkflowModelUseCase"
      },
      "description": "The concepts must belong to workflow models with specified use cases.\nMultiple values are joined using an OR condition."
    },
    "workflowId": {
      "type": "string",
      "description": "The id of workflow. If no id is provided, then application base workflow is used."
    }
  }
}