{
  "type": "object",
  "properties": {
    "sampleMs": {
      "type": "integer",
      "format": "int64",
      "description": "sample_ms is the sampling rate at which frame annotations are interpolated.\nIf sample_ms is zero, then the dataset default_processing_info value is used.\nIf the dataset default is zero or not set, then the input frame prediction\nsampling rate is used."
    }
  },
  "description": "FrameInterpolationInfo contains information about frame annotations\ninterpolated from other video annotations, such as image object-detection\nregions generated from video object-tracking regions."
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "title": "Id value for referencing. Ex. \"en\""
    },
    "name": {
      "type": "string",
      "title": "Display name of the tag. Ex. \"English\""
    }
  }
}

{
  "type": "object",
  "title": "Geo",
  "properties": {
    "geoBox": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiGeoBoxedPoint"
      },
      "title": "NOTE: inconsistency: should have been geo_boxed_points"
    },
    "geoLimit": {
      "$ref": "#/components/schemas/apiGeoLimit"
    },
    "geoPoint": {
      "$ref": "#/components/schemas/apiGeoPoint"
    }
  }
}

{
  "type": "object",
  "title": "GeoBoxedPoint",
  "properties": {
    "geoPoint": {
      "$ref": "#/components/schemas/apiGeoPoint"
    }
  }
}

{
  "type": "object",
  "title": "GeoLimit",
  "properties": {
    "type": {
      "type": "string"
    },
    "value": {
      "type": "number",
      "format": "float"
    }
  }
}

{
  "type": "object",
  "title": "GeoPoint",
  "properties": {
    "latitude": {
      "type": "number",
      "format": "float"
    },
    "longitude": {
      "type": "number",
      "format": "float"
    }
  }
}

{
  "type": "object",
  "title": "ResourceCountResponse",
  "properties": {
    "inputs": {
      "type": "string",
      "format": "int64"
    },
    "models": {
      "type": "string",
      "format": "int64"
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "modules": {
      "type": "string",
      "format": "int64"
    },
    "datasets": {
      "type": "string",
      "format": "int64"
    },
    "workflows": {
      "type": "string",
      "format": "int64"
    }
  }
}

{
  "type": "object",
  "properties": {
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "manifestUrl": {
      "type": "string",
      "title": "MPEG-dash manifest as data-URI, base64-encoded\nCan be empty if status is FAILED\nCan be fallback manifest if status is MIXED_STATUS"
    }
  }
}

{
  "type": "object",
  "title": "Hit",
  "properties": {
    "appId": {
      "type": "string",
      "description": "The cfid of the app the asset came from."
    },
    "input": {
      "$ref": "#/components/schemas/apiInput"
    },
    "score": {
      "type": "number",
      "format": "float",
      "description": "This is the score for the ranked Hit results of the search query. This score is a number\nbetween 0.0 and 1.0 as it represents a confidence in the search Hit. For example, if you search\nfor \"car\" and get a close matching Hit, the score should be close to 1.0. If you get a score\nof close to 0.0 that means it's very disimilar to your query, in this case NOT a \"car\". There\nis a special intermediate score of 0.5 that means that the Hit is not really correlated with\nyour search query (ie. not similar or dissimlar to the query) which is a common occurrence\nwhen using negate queries.\nNote: some queries that are just filtering down your app of inputs may just return a score of\n1.0 for all Hits."
    },
    "userId": {
      "type": "string",
      "description": "The customer-facing id of the user who owns the app the asset came from."
    },
    "annotation": {
      "$ref": "#/components/schemas/clarifaiapiAnnotation"
    }
  }
}

{
  "type": "object",
  "properties": {
    "estimatedTotal": {
      "type": "string",
      "format": "uint64",
      "description": "The estimated total number of hits for the search query, not just the current page."
    }
  }
}

{
  "type": "object",
  "title": "HostedURL",
  "properties": {
    "sizes": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The sizes field lists which images of the different sizes are hosted in our storage. The URL\nof each hosted image can be obtained by joining the prefix, one of the sizes and suffix."
    },
    "prefix": {
      "type": "string",
      "description": "Prefix of the URL of every hosted image."
    },
    "suffix": {
      "type": "string",
      "description": "Suffix of an image stored in different sizes."
    },
    "crossorigin": {
      "type": "string",
      "title": "The crossorigin property of html media tag\nFor Secure Data Hosting this needs to be set to 'use-credentials'"
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "title": "old id"
    },
    "newId": {
      "type": "string",
      "title": "new id"
    }
  }
}

{
  "type": "object",
  "title": "Image",
  "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"
    },
    "imageInfo": {
      "$ref": "#/components/schemas/apiImageInfo"
    },
    "allowDuplicateUrl": {
      "type": "boolean"
    }
  }
}

{
  "type": "object",
  "properties": {
    "width": {
      "type": "integer",
      "title": "width",
      "format": "int32"
    },
    "format": {
      "type": "string",
      "title": "image format"
    },
    "height": {
      "type": "integer",
      "title": "height",
      "format": "int32"
    },
    "colorMode": {
      "type": "string",
      "title": "image color mode"
    }
  }
}

{
  "type": "object",
  "properties": {
    "params": {
      "type": "object",
      "description": "Used to configure model imports from third-party toolkits."
    }
  }
}

{
  "type": "object",
  "title": "Input",
  "properties": {
    "id": {
      "type": "string",
      "title": "The ID for the input"
    },
    "data": {
      "$ref": "#/components/schemas/apiData"
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "createdAt": {
      "type": "string",
      "title": "When the input 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"
    },
    "datasetIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "List of dataset IDs that this input is part of\nCurrently, this field is ONLY used to\n* search inputs part of dataset(s), e.g. in `PostSearches`, `PostInputsSearches` and `PostAnnotationsSearches` endpoints, and\n* to add inputs to dataset(s) in `PostInputs` endpoint.\nNote that this field is ignored for other endpoints, e.g. `GetInput`, `ListInputs` and `PatchInputs`."
    },
    "modifiedAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the input was modified."
    }
  }
}

{
  "type": "object",
  "properties": {
    "errors": {
      "type": "integer",
      "format": "int64"
    },
    "processed": {
      "type": "integer",
      "format": "int64"
    },
    "reindexed": {
      "type": "integer",
      "format": "int64"
    },
    "toProcess": {
      "type": "integer",
      "format": "int64"
    },
    "toReindex": {
      "type": "integer",
      "format": "int64"
    },
    "processing": {
      "type": "integer",
      "format": "int64"
    },
    "reindexing": {
      "type": "integer",
      "format": "int64"
    },
    "reindexErrors": {
      "type": "integer",
      "format": "int64"
    }
  },
  "description": "NOTE: inconsistency: this is weird mix of plural and singular words."
}

{
  "enum": [
    "INPUT_ID_CONFLICT_RESOLUTION_NOT_SET",
    "SKIP",
    "SUFFIX"
  ],
  "type": "string",
  "default": "INPUT_ID_CONFLICT_RESOLUTION_NOT_SET",
  "description": " - INPUT_ID_CONFLICT_RESOLUTION_NOT_SET: Defaults to SKIP\n - SKIP: Mark duplicate inputs as error and skip processing them.\n - SUFFIX: Add a suffix to inputs with conflicting IDs. Attempts numeric suffixes \"-1\" to \"-9\" and then a randomized suffix. Identical ID's in the same request are still treated as errors."
}

{
  "type": "object",
  "properties": {
    "inputIds": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  }
}

{
  "type": "object",
  "title": "InputInfo",
  "properties": {
    "params": {
      "type": "object",
      "description": "To control the inputs to the given model we allow a list of parameters\ndefined for each ModelType as a Struct (JSON object) here. During training or inference, the\nsettings contained within are sent to the training processor to alter the training process."
    },
    "fieldsMap": {
      "type": "object",
      "description": "Map from the api.Data field names to the underlying model graph's inputs. When using a\nPretrainedModelConfig the values in this map need to match the Triton config.pbtxt input names."
    },
    "baseEmbedModel": {
      "$ref": "#/components/schemas/apiModel"
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "title": "id of the job"
    },
    "appPat": {
      "type": "string",
      "title": "Personal Access Token to the application to which inputs are added"
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "uploads": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiUpload"
      },
      "title": "Archive uploads"
    },
    "progress": {
      "$ref": "#/components/schemas/apiInputsAddJobProgress"
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the job 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": "Most recent time when the job was updated.\nThe format is https://www.ietf.org/rfc/rfc3339.txt.\nExample: \"2006-01-02T15:04:05.999999Z\"."
    },
    "callBackUrl": {
      "type": "string",
      "description": "If call back url is set, we will send a Post request to this endpoint with job status."
    },
    "extractionJobs": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiInputsExtractionJob"
      },
      "title": "Sub-jobs that extract inputs from the cloud and/or archives"
    }
  }
}

{
  "type": "object",
  "properties": {
    "failedCount": {
      "type": "string",
      "format": "uint64"
    },
    "pendingCount": {
      "type": "string",
      "format": "uint64"
    },
    "successCount": {
      "type": "string",
      "format": "uint64"
    },
    "inProgressCount": {
      "type": "string",
      "format": "uint64"
    }
  }
}

{
  "type": "object",
  "properties": {
    "url": {
      "$ref": "#/components/schemas/apiDataSourceURL"
    },
    "inputTemplate": {
      "$ref": "#/components/schemas/apiInput"
    },
    "inputsAddJobId": {
      "type": "string",
      "description": "Collect statistics about created inputs in job with given ID.\nOn Post call:\n* If job ID is empty, then job is automatically created with random ID.\n* If job ID is non-empty, then a new job will be created with given ID."
    },
    "inputIdConflictResolution": {
      "$ref": "#/components/schemas/apiInputIDConflictResolution"
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "title": "ID of extraction job"
    },
    "url": {
      "type": "string",
      "title": "Url of archive or bucket"
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "progress": {
      "$ref": "#/components/schemas/apiInputsExtractionJobProgress"
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the extraction job was started.\nThe format is https://www.ietf.org/rfc/rfc3339.txt.\nExample: \"2006-01-02T15:04:05.999999Z\"."
    },
    "modifiedAt": {
      "type": "string",
      "format": "date-time",
      "description": "Most recent time when the extraction job was updated.\nThe format is https://www.ietf.org/rfc/rfc3339.txt.\nExample: \"2006-01-02T15:04:05.999999Z\"."
    },
    "inputTemplate": {
      "$ref": "#/components/schemas/apiInput"
    },
    "inputIdConflictResolution": {
      "$ref": "#/components/schemas/apiInputIDConflictResolution"
    }
  }
}

{
  "type": "object",
  "properties": {
    "textInputsCount": {
      "type": "string",
      "format": "uint64"
    },
    "audioInputsCount": {
      "type": "string",
      "format": "uint64"
    },
    "imageInputsCount": {
      "type": "string",
      "format": "uint64"
    },
    "videoInputsCount": {
      "type": "string",
      "format": "uint64"
    },
    "failedArchivesCount": {
      "type": "string",
      "format": "uint64"
    },
    "pendingArchivesCount": {
      "type": "string",
      "format": "uint64"
    },
    "completedArchivesCount": {
      "type": "string",
      "format": "uint64"
    },
    "inProgressArchivesCount": {
      "type": "string",
      "format": "uint64"
    }
  }
}

{
  "type": "object",
  "properties": {
    "appPat": {
      "type": "string",
      "title": "Personal Access Token to the application to which inputs are added"
    },
    "upload": {
      "$ref": "#/components/schemas/apiUpload"
    },
    "inputTemplate": {
      "$ref": "#/components/schemas/apiInput"
    },
    "inputsAddJobId": {
      "type": "string",
      "description": "Collect statistics about created inputs in job with given ID.\n* If job ID is empty, then job is automatically created with random ID.\n* If job ID is non-empty, then a new job will be created with given ID."
    },
    "inputIdConflictResolution": {
      "$ref": "#/components/schemas/apiInputIDConflictResolution"
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "A unique id for this install. This will be used in the browser url."
    },
    "appId": {
      "type": "string",
      "description": "The app_id the ModuleVersion is installed into (not necessary where the ModuleVersion was\ncreated). This doesn't have to be provided in requests to install, but will be returned in\nresponses."
    },
    "keyId": {
      "type": "string",
      "description": "The key ID to use for making requests to the API for this module.\nThis key is associated to this installed module version by PostInstalledModuleVersionsKey\nrequest. The key is associated with the CALLER not the App Owner where this module is installed\nnor the author of the module. This allows the module to act on behalf of the caller at all\ntimes so we get proper permissions the caller has (such as if they are stranger, teammate or\ncollaborator). This key should be a personal access token to enable modules to work across apps\nand have necessary abilities beyond what app-specific keys offer."
    },
    "userId": {
      "type": "string",
      "description": "The user that the app belongs to where the ModuleVersion is installed into (not necessary where\nthe ModuleVersion was created). This doesn't have to be provided in requests to install, but\nwill be returned in responses."
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the install was created."
    },
    "deployUrl": {
      "type": "string",
      "description": "The URL of where this app module version is deployed.\nIf you provide this deploy_url when creating the install then it will\nbe treated as a pre-deployed module. You can only use a pre-deployed module\nin when installing to an app_id that you own as the creator of the module.\nIf you want to install someone elses module or to rely on Clarifai deploying\nyour module for you, leave deploy_url empty when creating the install.\nIf it is left empty, then deployment will occur when this module version is\ninstalled into an app using the git_commit_url of the ModuleVersion."
    },
    "modifiedAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the install was last modified."
    },
    "visibility": {
      "$ref": "#/components/schemas/clarifaiapiVisibility"
    },
    "moduleVersion": {
      "$ref": "#/components/schemas/apiModuleVersion"
    }
  }
}

{
  "type": "object",
  "title": "Key",
  "properties": {
    "id": {
      "type": "string",
      "description": "The id of this key, it is used for authorization."
    },
    "apps": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiApp"
      },
      "description": "The apps that this key give you access to, it is empty if this key is personal_access_token\nAPI key can only give you access to a single app."
    },
    "type": {
      "type": "string",
      "title": "The type of key, it can be api_key or personal_access_token, the default value is api_key"
    },
    "scopes": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "The low-level scopes this key has"
    },
    "createdAt": {
      "type": "string",
      "title": "When the key 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"
    },
    "endpoints": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "The endpoint-level scopes this key has"
    },
    "expiresAt": {
      "type": "string",
      "title": "When does the key expires, the key won't expire if this is empty",
      "format": "date-time"
    },
    "description": {
      "type": "string",
      "title": "The description"
    },
    "authorizedIdpIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "list of idp ids at which key is currently authorized"
    }
  }
}

{
  "type": "object",
  "properties": {
    "k1": {
      "type": "integer",
      "format": "int64"
    },
    "k2": {
      "type": "integer",
      "format": "int64"
    }
  }
}

{
  "type": "object",
  "properties": {
    "skeleton": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiKeypointEdge"
      },
      "description": "Defines the connections between keypoint_names. Each value represents the index in keypoint_names."
    },
    "keypointNames": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "Names of the keypoints"
    }
  }
}

{
  "type": "object",
  "title": "A Knowledge Graph is a logical subsets of edges in the overall Concept Graph",
  "properties": {
    "id": {
      "type": "string",
      "title": "ID of the knowledge graph"
    },
    "name": {
      "type": "string",
      "title": "Name of the knowledge graph"
    },
    "description": {
      "type": "string",
      "title": "Human readable description of the knowledge graph"
    },
    "examplesAppId": {
      "type": "string",
      "title": "The app that contains the images that correspond to the concepts in the knowledge graph"
    },
    "sampledExamplesAppId": {
      "type": "string",
      "title": "The app that contains the sample images that we want to show the customer for the concepts in the knowledge graph"
    }
  }
}

{
  "type": "object",
  "title": "LOPQEvalResult",
  "properties": {
    "k": {
      "type": "integer",
      "format": "int32",
      "description": "Rank k for which all metrics are reported."
    },
    "lopqNdcg": {
      "type": "number",
      "title": "Normalized Discounted Cumulative Gain (NDCG) @ k with a ground truth inferred from annotations\nand/or prediction for this evaluation LOPQ model.\nNDCG uses individual relevance scores of each returned image to evaluate the usefulness, or\ngain, of a document based on its position in the result list. The premise of DCG is that\nhighly relevant documents appearing lower in a search result list should be penalized as the\ngraded relevance value is reduced logarithmically proportional to the position of the result.\nSee: https://en.wikipedia.org/wiki/Information_retrieval#Discounted_cumulative_gain",
      "format": "float",
      "description": "To compute the relevance score between two images we consider two cases:\n1) Only one label for each image\nAn image is relevant to an image query iff they are labeled the same (score 1), and\nnot relevant otherwise (score 0)\n2) Multiple labels for each image\nHere an image relevancy with respect to a single image query is measured by f-beta score\nassuming the query image list of labels as ground truth and comparing them with that of\nthe search result. These labels can come from image annotations or if substitute_annotation_misses\nis set, predictions of base classifier where any prediction with prob < prob_threshold are\ndiscarded. To quantify the relevancy score of a single search result we opt to compute precision\nand recall @ k for simplicity, and combine them with f-beta score to obtain a single number."
    },
    "bruteForceNdcg": {
      "type": "number",
      "format": "float",
      "description": "Brute force NDCG which gives a baseline to compare to and is a measure of how good\nthe embeddings are."
    },
    "recallVsBruteForce": {
      "type": "number",
      "format": "float",
      "description": "Recall @ k assuming the brute force search is the ground truth."
    },
    "kendallTauVsBruteForce": {
      "type": "number",
      "format": "float",
      "description": "Kendall's tau correlation @ k assuming the brute force search is the ground truth."
    },
    "mostFrequentCodePercent": {
      "type": "number",
      "format": "float",
      "description": "The percentage of the most frequent code in the indexed part of evaluation data."
    }
  }
}

{
  "type": "object",
  "title": "LabelCount",
  "properties": {
    "count": {
      "type": "integer",
      "format": "int64"
    },
    "concept": {
      "$ref": "#/components/schemas/apiConcept"
    },
    "conceptName": {
      "type": "string"
    }
  }
}

{
  "type": "object",
  "title": "LabelDistribution",
  "properties": {
    "positiveLabelCounts": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiLabelCount"
      }
    }
  }
}

{
  "type": "object",
  "title": "LabelOrder",
  "properties": {
    "id": {
      "type": "string",
      "title": "id of the order"
    },
    "name": {
      "type": "string",
      "title": "name of the order"
    },
    "task": {
      "$ref": "#/components/schemas/apiTask"
    },
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "createdAt": {
      "type": "string",
      "format": "date-time",
      "description": "When the label order 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": "Most recent time when the label order was updated.\nThe format is https://www.ietf.org/rfc/rfc3339.txt.\nExample: \"2006-01-02T15:04:05.999999Z\"."
    },
    "autoRelease": {
      "type": "boolean",
      "description": "if set to true, automatically release the labels once passed clarifai review."
    },
    "allowEmptyTag": {
      "type": "boolean",
      "description": "allow input without any tag."
    },
    "desiredFulfillTime": {
      "type": "string",
      "title": "User desired estimation when the task should be done",
      "format": "date-time"
    },
    "estimateFulfillTime": {
      "type": "string",
      "format": "date-time",
      "description": "Clarifai estimation when the task should be done ."
    }
  }
}

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

{
  "type": "object",
  "properties": {
    "dims": {
      "type": "array",
      "items": {
        "type": "integer",
        "format": "int32"
      },
      "title": "Supported dimensions\nExample: [-1,4] is a 2-dimensional array with the first dimension of variablesize, but second dimension with a static size: [[1,2,3,4],[4,5,6,7],...]"
    },
    "maxDims": {
      "type": "array",
      "items": {
        "type": "integer",
        "format": "int32"
      },
      "description": "Max dimension size, applicable to layers that can have flexible sizes."
    },
    "dataType": {
      "$ref": "#/components/schemas/apiDataType"
    },
    "description": {
      "type": "string",
      "title": "Description about the dimensions"
    }
  }
}

{
  "type": "object",
  "title": "ListOpenSourceLicensesResponse",
  "properties": {
    "status": {
      "$ref": "#/components/schemas/apistatusStatus"
    },
    "licenses": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  }
}

{
  "type": "object",
  "properties": {
    "image": {
      "$ref": "#/components/schemas/apiImage"
    }
  },
  "description": "Segmentation mask."
}

{
  "type": "object",
  "title": "MetricsSummary",
  "properties": {
    "lopqMetrics": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiLOPQEvalResult"
      }
    },
    "top1Accuracy": {
      "type": "number",
      "format": "float"
    },
    "top5Accuracy": {
      "type": "number",
      "format": "float"
    },
    "macroAvgRecall": {
      "type": "number",
      "format": "float"
    },
    "macroAvgRocAuc": {
      "type": "number",
      "format": "float"
    },
    "macroStdRocAuc": {
      "type": "number",
      "format": "float"
    },
    "macroAvgF1Score": {
      "type": "number",
      "format": "float"
    },
    "macroStdF1Score": {
      "type": "number",
      "format": "float"
    },
    "macroAvgPrecision": {
      "type": "number",
      "format": "float"
    },
    "meanAvgPrecisionIou50": {
      "type": "number",
      "format": "float"
    },
    "meanAvgPrecisionIouRange": {
      "type": "number",
      "format": "float"
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "The model's ID. Must be unique within a particular app and URL-friendly."
    },
    "name": {
      "type": "string",
      "description": "DEPRECATED: Please use the model id to name the model."
    },
    "task": {
      "type": "string",
      "title": "The task the model was trained to do"
    },
    "appId": {
      "type": "string",
      "description": "The app the model belongs to."
    },
    "image": {
      "$ref": "#/components/schemas/apiImage"
    },
    "notes": {
      "type": "string",
      "description": "Notes for the model\nThis field should be used for in-depth notes and supports up to 64Kbs."
    },
    "userId": {
      "type": "string",
      "description": "The user id that the model belongs to."
    },
    "presets": {
      "type": "object"
    },
    "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"
    },
    "toolkits": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "Tags from toolkits category"
    },
    "useCases": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "title": "Tags from use_cases category"
    },
    "createdAt": {
      "type": "string",
      "title": "When the model 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\n the following from the API:\n \"2017-04-11T21:50:50.223962Z\"",
      "format": "date-time"
    },
    "isStarred": {
      "type": "boolean",
      "title": "Is starred by the requesting user (only showed on get/list requests)\nPlease use PostModelStars/DeleteModelStars endpoints to star/unstar a model"
    },
    "languages": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Tags from languages category."
    },
    "starCount": {
      "type": "integer",
      "title": "How many users have starred the model (only showed on get/list requests)\nComputed value, not editable",
      "format": "int32"
    },
    "modifiedAt": {
      "type": "string",
      "title": "When was the most recent model version created at",
      "format": "date-time"
    },
    "outputInfo": {
      "$ref": "#/components/schemas/apiOutputInfo"
    },
    "visibility": {
      "$ref": "#/components/schemas/clarifaiapiVisibility"
    },
    "description": {
      "type": "string",
      "title": "Short description about this model"
    },
    "displayName": {
      "type": "string",
      "description": "DEPRECATED: Please use the model id to name the model."
    },
    "modelTypeId": {
      "type": "string",
      "description": "The ModelType.Id that is used for this model. This is used for all versions and you cannot\nchange model_type_id between versions of the same model."
    },
    "modelVersion": {
      "$ref": "#/components/schemas/apiModelVersion"
    },
    "checkConsents": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "languagesFull": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiFullTag"
      },
      "description": "Tags from languages category with names, only used in responses."
    },
    "bookmarkOrigin": {
      "$ref": "#/components/schemas/apiBookmarkOrigin"
    },
    "defaultEvalInfo": {
      "$ref": "#/components/schemas/apiEvalInfo"
    },
    "workflowRecommended": {
      "type": "boolean",
      "title": "Whether it's recommended that this model is used within a workflow"
    }
  },
  "description": "This is the Model object which represents a created model in the platform.\nEach model has a particular type denoted by the model_type_id.\nWhen creating a Model with PostModels the following happens:\n - if the ModelType is trainable, then a new ModelVersion is created that is\n   - UNTRAINED status by default\n   - TRAINED status if a ModelVersion was included with PretrainedModelConfig in PostModels\n - if the ModelType is not trainable, then a new ModelVersion is created with TRAINED status.\nTo modify config settings like OutputInfo for the Model you an use PatchModels. This will\nalso create a new ModelVersion, potentially UNTRAINED following the same rules as above.\nThe fields that are patchable include Model.name, Model.display_name and Model.output_info\n(except the Model.output_info.type and Model.output_info.type_ext)."
}

{
  "type": "object",
  "properties": {
    "shapes": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiLayerShape"
      },
      "description": "Description of the expected shape. Can support multiple support layer shapes."
    },
    "description": {
      "type": "string",
      "title": "Brief description about the layer if needed"
    },
    "dataFieldName": {
      "type": "string",
      "title": "The api.Data field this layer will be parsed into"
    },
    "requiresLabelFilename": {
      "type": "boolean",
      "title": "Whether this layer should have a label_filename specified and provided"
    }
  }
}

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

{
  "type": "object",
  "title": "ModelQuery",
  "properties": {
    "name": {
      "type": "string",
      "description": "The name ofthe field. This supports wilcard queries like \"gen*\" to match \"general\" as an example."
    },
    "modelTypeId": {
      "type": "string",
      "description": "Filter models by the specific model_type_id. See ListModelTypes for the list of ModelType.Id's\nsupported."
    }
  }
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "title": "Id of the reference"
    },
    "url": {
      "type": "string",
      "title": "address of resource"
    },
    "name": {
      "type": "string",
      "title": "name of link"
    },
    "modelId": {
      "type": "string",
      "description": "The id of the model this Model reference is tied to."
    },
    "metadata": {
      "type": "object",
      "title": "To handle arbitrary json metadata:\nhttps://github.com/google/protobuf/blob/master/src/google/protobuf/struct.proto"
    }
  },
  "description": "A link to a html/markdown/text file that stores reference material tied to a model."
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "A unique identifier for this model type."
    },
    "title": {
      "type": "string",
      "description": "A display title for this model."
    },
    "creatable": {
      "type": "boolean",
      "description": "Is this model creatable. We have some pre-trained model types that users cannot create yet in\nmodel mode."
    },
    "trainable": {
      "type": "boolean",
      "description": "Is this model trainable in our platform."
    },
    "description": {
      "type": "string",
      "description": "Description of this model type."
    },
    "inputFields": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The list of input fields that this model expects as inputs.\nUsed to validate that request input data has the expected fields."
    },
    "internalOnly": {
      "type": "boolean",
      "description": "Is this model type only for internal users at this time."
    },
    "outputFields": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The list of output fields that this model accepts."
    },
    "evaluationType": {
      "$ref": "#/components/schemas/apiEvaluationType"
    },
    "modelTypeFields": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiModelTypeField"
      },
      "description": "The remaining fields are definitions of the configurable fields that exist."
    },
    "expectedInputLayers": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiModelLayerInfo"
      },
      "description": "Expected input layers of an uploaded model."
    },
    "expectedOutputLayers": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiModelLayerInfo"
      },
      "title": "Expected output layers of an uploaded model"
    },
    "requiresSequentialFrames": {
      "type": "boolean",
      "description": "For sequence models we need to know when processing that they require temporal time frames\nin sequential order. This will be true for model types like trackers as an example."
    }
  },
  "description": "ModelType is a definition of a set of models that generally have the same input and output fields.\nThis is used to understand more about the possible models in our platform."
}

{
  "type": "object",
  "title": "ModelTypeEnumOption",
  "properties": {
    "id": {
      "type": "string",
      "description": "The unique value of the enum option."
    },
    "aliases": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiModelTypeEnumOptionAlias"
      },
      "title": "List of other ID values that are equivalent with this ID.\nThis allows the user to choose this option by multiple IDs.\nExample: if enum is \"Phone Number Prefix\", you could add an option that is selectable by two values:\n1. ID: \"Estonia\"\n2. Alias: 37"
    },
    "description": {
      "type": "string",
      "description": "Optional description for this enum option."
    },
    "recommended": {
      "type": "boolean",
      "description": "Whether this is the recommended enum option. Set to `true` when there\nare multiple options, and one is shown to be better than the others."
    },
    "internalOnly": {
      "type": "boolean",
      "description": "If this enum option should be internal only."
    },
    "modelTypeFields": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiModelTypeField"
      },
      "description": "These are additional fields that are specific to this enum choice. This allows\nus to use enums to control configuration settings as well."
    }
  }
}

{
  "type": "object",
  "properties": {
    "idInt": {
      "type": "string",
      "format": "int64",
      "description": "Integer alias for id."
    },
    "wildcardString": {
      "type": "string",
      "description": "String that can contain wild cards and the regex needs to match."
    }
  }
}

{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "description": "The path where the value of the field will be stored in the model version object.\nExample:\n\"output_info.data\" would be the Data message in the OutputInfo message.\n\"output_info.output_config.language\" is in the OutputConfig message within OutputInfo\n\"input_info.params\" is in the params struct within InputInfo.\n\"output_info.params\" is in the params struct within OutputInfo.\n\"train_info.params\" is in the params struct within TrainInfo.\nand so on."
    },
    "required": {
      "type": "boolean",
      "description": "If this field is a required field. If True then during validation you won't be able to create\na model of this type with providing a value for this field. When False, the ModelType's\ndefault_value will be used for this field."
    },
    "fieldType": {
      "$ref": "#/components/schemas/ModelTypeFieldModelTypeFieldType"
    },
    "description": {
      "type": "string",
      "description": "Description for this field."
    },
    "placeholder": {
      "type": "string",
      "description": "Placeholder text for the UI element."
    },
    "defaultValue": {
      "description": "A default value. We use the Value field because we want to have structured data (just like\ngoogle.protobuf.Struct but this is just a single value)."
    },
    "internalOnly": {
      "type": "boolean",
      "description": "If this field should appear for internal users only."
    },
    "modelTypeRangeInfo": {
      "$ref": "#/components/schemas/apiModelTypeRangeInfo"
    },
    "modelTypeEnumOptions": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/apiModelTypeEnumOption"
      },
      "description": "List of options of the ENUM type and potentially additional fields they bring with them."
    }
  },
  "description": "ModelTypeField stores a field value of a configurable type."
}

{
  "type": "object",
  "title": "ModelTypeRangeInfo",
  "properties": {
    "max": {
      "type": "number",
      "format": "float",
      "description": "The end of the range as a float."
    },
    "min": {
      "type": "number",
      "format": "float",
      "description": "The start of the range as a float."
    },
    "step": {
      "type": "number",
      "format": "float",
      "description": "An optional step size for the range. If provided then only values at that step size will be\nrounded to. For example if step is 0.02 then 0.0245 will round to 0.02."
    }
  }
}