{
  "swagger": "2.0",
  "info": {
    "title": "Checklist execution service",
    "version": "0.1507.0",
    "description": "Send your API key as a bearer token: `Authorization: Bearer <api key>`."
  },
  "consumes": [
    "application/json"
  ],
  "produces": [
    "application/json"
  ],
  "securityDefinitions": {
    "ApiKey": {
      "type": "apiKey",
      "in": "header",
      "name": "Authorization",
      "description": "Your API key as a bearer token: `Authorization: Bearer <api key>`."
    }
  },
  "security": [
    {
      "ApiKey": []
    }
  ],
  "paths": {
    "/scout/v2/checklist-execution/checklist-live-status": {
      "post": {
        "operationId": "ChecklistExecutionService_checklistLiveStatus",
        "summary": "Checklist live status",
        "tags": [
          "Checklist Execution Service"
        ],
        "description": "For each request, get the latest status for each check in a streaming checklist against the given asset. Requests with more than 10,000 checklists will be rejected.",
        "parameters": [
          {
            "name": "request",
            "in": "body",
            "schema": {
              "$ref": "#/definitions/BatchChecklistLiveStatusRequest"
            },
            "required": true,
            "x-example": {
              "requests": [
                {
                  "checklistRid": "<checklist rid>",
                  "assetRid": "<asset rid>"
                }
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/BatchChecklistLiveStatusResponse"
            },
            "x-example": {
              "checklistLiveStatusResponses": [
                {
                  "checklistRid": "<checklist rid>",
                  "assetRid": "<asset rid>",
                  "status": {
                    "type": "running",
                    "running": {
                      "commitId": "<commit id>",
                      "checkResults": [
                        {
                          "status": {
                            "type": "pass",
                            "pass": {}
                          },
                          "checkRid": "<check rid>",
                          "checkParameterIndex": 1
                        }
                      ]
                    }
                  }
                }
              ]
            }
          }
        }
      }
    },
    "/scout/v2/checklist-execution/execute-streaming-checklist": {
      "post": {
        "operationId": "ChecklistExecutionService_executeStreamingChecklist",
        "summary": "Execute streaming checklist",
        "tags": [
          "Checklist Execution Service"
        ],
        "description": "Triggers a checklist to run continuously against assets. If the checklist is already running for the given asset, replace the existing configuration with the one specified by the request.",
        "parameters": [
          {
            "name": "request",
            "in": "body",
            "schema": {
              "$ref": "#/definitions/ExecuteChecklistForAssetsRequest"
            },
            "required": true,
            "x-example": {
              "checklist": "<checklist rid>",
              "evaluationDelay": {
                "seconds": 1,
                "nanos": 1
              },
              "recoveryDelay": {
                "seconds": 1,
                "nanos": 1
              }
            }
          }
        ],
        "responses": {
          "204": {
            "description": "No content."
          }
        }
      }
    },
    "/scout/v2/checklist-execution/list-streaming-checklists": {
      "post": {
        "operationId": "ChecklistExecutionService_listStreamingChecklist",
        "summary": "List streaming checklist",
        "tags": [
          "Checklist Execution Service"
        ],
        "description": "Lists all running streaming checklists.",
        "parameters": [
          {
            "name": "request",
            "in": "body",
            "schema": {
              "$ref": "#/definitions/ListStreamingChecklistRequest"
            },
            "required": true,
            "x-example": {
              "pageSize": 1,
              "workspaces": [
                "<workspace rid>"
              ],
              "pageToken": "<page token>"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/ListStreamingChecklistResponse"
            },
            "x-example": {
              "checklists": [
                "<checklist rid>"
              ],
              "nextPageToken": "<next page token>"
            }
          }
        }
      }
    },
    "/scout/v2/checklist-execution/list-streaming-checklists-for-asset": {
      "post": {
        "operationId": "ChecklistExecutionService_listStreamingChecklistForAsset",
        "summary": "List streaming checklist for asset",
        "tags": [
          "Checklist Execution Service"
        ],
        "description": "Retrieves all streaming checklists for a given asset.",
        "parameters": [
          {
            "name": "request",
            "in": "body",
            "schema": {
              "$ref": "#/definitions/ListStreamingChecklistForAssetRequest"
            },
            "required": true,
            "x-example": {
              "assetRid": "<asset rid>"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/ListStreamingChecklistForAssetResponse"
            },
            "x-example": {
              "checklists": [
                "<checklist rid>"
              ],
              "nextPageToken": "<next page token>"
            }
          }
        }
      }
    },
    "/scout/v2/checklist-execution/get-streaming-checklist/{checklistRid}": {
      "get": {
        "operationId": "ChecklistExecutionService_getStreamingChecklist",
        "summary": "Get streaming checklist",
        "tags": [
          "Checklist Execution Service"
        ],
        "description": "Retrieves the set of assets and their execution configurations for a streaming checklist specified by the checklistRid.",
        "parameters": [
          {
            "name": "checklistRid",
            "in": "path",
            "type": "string",
            "format": "rid",
            "x-alias": "ChecklistRid",
            "required": true
          }
        ],
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/StreamingChecklistInfo"
            },
            "x-example": {
              "checklistRid": "<checklist rid>",
              "assetConfigurations": {
                "<key>": {
                  "notificationConfigurations": [
                    {
                      "integrationRid": "<integration rid>",
                      "notificationFilters": [
                        "EXECUTION_ERROR"
                      ],
                      "appendedWorkbookRid": "<notebook rid>",
                      "tags": [
                        "<tags>"
                      ],
                      "muteUntil": "2026-01-01T00:00:00Z"
                    }
                  ],
                  "evaluationDelay": {
                    "seconds": 1,
                    "nanos": 1
                  },
                  "recoveryDelay": {
                    "seconds": 1,
                    "nanos": 1
                  },
                  "autoCreateEvents": true
                }
              }
            }
          }
        }
      }
    },
    "/scout/v2/checklist-execution/get-streaming-checklists": {
      "post": {
        "operationId": "ChecklistExecutionService_batchGetStreamingChecklist",
        "summary": "Batch get streaming checklist",
        "tags": [
          "Checklist Execution Service"
        ],
        "description": "Retrieves the set of assets and their execution configurations for all streaming checklists specified by the request. If a streaming checklist is not found, it will not be included in the response.",
        "parameters": [
          {
            "name": "request",
            "in": "body",
            "schema": {
              "$ref": "#/definitions/BatchGetStreamingChecklistRequest"
            },
            "required": true,
            "x-example": {
              "checklistRids": [
                "<checklist rid>"
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/BatchGetStreamingChecklistResponse"
            },
            "x-example": {
              "streamingChecklistInfos": {
                "<key>": {
                  "checklistRid": "<checklist rid>",
                  "assetConfigurations": {
                    "<key>": {
                      "notificationConfigurations": [
                        {
                          "integrationRid": "<integration rid>",
                          "notificationFilters": [
                            "EXECUTION_ERROR"
                          ],
                          "appendedWorkbookRid": "<notebook rid>",
                          "tags": [
                            "<tags>"
                          ],
                          "muteUntil": "2026-01-01T00:00:00Z"
                        }
                      ],
                      "evaluationDelay": {
                        "seconds": 1,
                        "nanos": 1
                      },
                      "recoveryDelay": {
                        "seconds": 1,
                        "nanos": 1
                      },
                      "autoCreateEvents": true
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/scout/v2/checklist-execution/stop-streaming-checklist/{checklistRid}": {
      "delete": {
        "operationId": "ChecklistExecutionService_stopStreamingChecklist",
        "summary": "Stop streaming checklist",
        "tags": [
          "Checklist Execution Service"
        ],
        "description": "Stops the execution of a streaming checklist on all assets.",
        "parameters": [
          {
            "name": "checklistRid",
            "in": "path",
            "type": "string",
            "format": "rid",
            "x-alias": "ChecklistRid",
            "required": true
          }
        ],
        "responses": {
          "204": {
            "description": "No content."
          }
        }
      }
    },
    "/scout/v2/checklist-execution/stop-streaming-checklist-for-assets": {
      "post": {
        "operationId": "ChecklistExecutionService_stopStreamingChecklistForAssets",
        "summary": "Stop streaming checklist for assets",
        "tags": [
          "Checklist Execution Service"
        ],
        "description": "Stops the execution of a streaming checklist for a given set of assets.",
        "parameters": [
          {
            "name": "request",
            "in": "body",
            "schema": {
              "$ref": "#/definitions/StopStreamingChecklistForAssetsRequest"
            },
            "required": true,
            "x-example": {
              "checklist": "<checklist rid>"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "No content."
          }
        }
      }
    },
    "/scout/v2/checklist-execution/reload-streaming-checklist/{checklistRid}": {
      "post": {
        "operationId": "ChecklistExecutionService_reloadStreamingChecklist",
        "summary": "Reload streaming checklist",
        "tags": [
          "Checklist Execution Service"
        ],
        "description": "Reloads the state of the streaming checklist for the given checklistRid.",
        "parameters": [
          {
            "name": "checklistRid",
            "in": "path",
            "type": "string",
            "format": "rid",
            "x-alias": "ChecklistRid",
            "required": true
          }
        ],
        "responses": {
          "204": {
            "description": "No content."
          }
        }
      }
    },
    "/scout/v2/checklist-execution/validate-checklist-resolution": {
      "post": {
        "operationId": "ChecklistExecutionService_validateChecklistResolution",
        "summary": "Validate checklist resolution",
        "tags": [
          "Checklist Execution Service"
        ],
        "description": "Validates that the channels referenced by the checklist can be resolved against the data sources.",
        "parameters": [
          {
            "name": "request",
            "in": "body",
            "schema": {
              "$ref": "#/definitions/BatchValidateChecklistResolutionRequest"
            },
            "required": true,
            "x-example": {
              "requests": [
                {
                  "checklistRid": "<checklist rid>",
                  "assetRid": "<asset rid>"
                }
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/BatchValidateChecklistResolutionResponse"
            },
            "x-example": {
              "checklistResults": [
                {
                  "checklistRid": "<checklist rid>",
                  "assetRid": "<asset rid>",
                  "resolutionStatus": [
                    {
                      "checkRid": "<check rid>",
                      "checkParameterIndex": 1,
                      "invalidStreamingComputeNodes": [
                        "POINT_PERSISTENCE"
                      ],
                      "channels": [
                        {
                          "channelLocator": {
                            "dataSourceRef": "<data source ref name>",
                            "channel": "<channel>",
                            "tags": {
                              "<key>": "<tag value>"
                            },
                            "asset": "<asset ref name>",
                            "run": "<run ref name>",
                            "inputId": "<input id>"
                          },
                          "resolutionStatus": "RESOLVED"
                        }
                      ],
                      "resolutionError": {
                        "name": "<name>",
                        "message": "<message>",
                        "errorInstanceId": "<error instance id>",
                        "statusCode": 1,
                        "params": {
                          "<key>": "<value>"
                        }
                      }
                    }
                  ]
                }
              ]
            }
          }
        }
      }
    }
  },
  "definitions": {
    "SerializableError": {
      "description": "A SerializableError is a representation of a ServiceException that exists to send error results to clients as part of a response object when directly throwing an exception is undesirable.",
      "type": "object",
      "properties": {
        "name": {
          "type": "string"
        },
        "message": {
          "type": "string"
        },
        "errorInstanceId": {
          "type": "string"
        },
        "statusCode": {
          "type": "integer",
          "format": "int32"
        },
        "params": {
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        }
      },
      "required": [
        "name",
        "errorInstanceId",
        "statusCode"
      ]
    },
    "ChannelLocator": {
      "type": "object",
      "properties": {
        "dataSourceRef": {
          "type": "string",
          "x-alias": "DataSourceRefName"
        },
        "channel": {
          "type": "string",
          "x-alias": "Channel"
        },
        "tags": {
          "type": "object",
          "additionalProperties": {
            "type": "string",
            "x-alias": "TagValue"
          },
          "x-map-key": "TagName"
        },
        "asset": {
          "type": "string",
          "x-alias": "AssetRefName"
        },
        "run": {
          "type": "string",
          "x-alias": "RunRefName"
        },
        "inputId": {
          "type": "string"
        }
      },
      "required": [
        "dataSourceRef",
        "channel"
      ]
    },
    "AssetStreamConfiguration": {
      "type": "object",
      "properties": {
        "notificationConfigurations": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/NotificationConfiguration"
          }
        },
        "evaluationDelay": {
          "$ref": "#/definitions/Duration"
        },
        "recoveryDelay": {
          "$ref": "#/definitions/Duration"
        },
        "autoCreateEvents": {
          "type": "boolean"
        }
      },
      "required": [
        "evaluationDelay",
        "recoveryDelay",
        "autoCreateEvents"
      ]
    },
    "BatchChecklistLiveStatusRequest": {
      "type": "object",
      "properties": {
        "requests": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/ChecklistLiveStatusRequest"
          }
        }
      },
      "example": {
        "requests": [
          {
            "checklistRid": "<checklist rid>",
            "assetRid": "<asset rid>"
          }
        ]
      }
    },
    "BatchChecklistLiveStatusResponse": {
      "type": "object",
      "properties": {
        "checklistLiveStatusResponses": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/ChecklistLiveStatusResponse"
          }
        }
      }
    },
    "BatchGetStreamingChecklistRequest": {
      "type": "object",
      "properties": {
        "checklistRids": {
          "type": "array",
          "items": {
            "type": "string",
            "format": "rid",
            "x-alias": "ChecklistRid"
          },
          "uniqueItems": true
        }
      },
      "example": {
        "checklistRids": [
          "<checklist rid>"
        ]
      }
    },
    "BatchGetStreamingChecklistResponse": {
      "type": "object",
      "properties": {
        "streamingChecklistInfos": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#/definitions/StreamingChecklistInfo"
          },
          "x-map-key": "ChecklistRid"
        }
      }
    },
    "BatchValidateChecklistResolutionRequest": {
      "type": "object",
      "properties": {
        "requests": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/ValidateChecklistResolutionRequest"
          }
        }
      },
      "example": {
        "requests": [
          {
            "checklistRid": "<checklist rid>",
            "assetRid": "<asset rid>"
          }
        ]
      }
    },
    "BatchValidateChecklistResolutionResponse": {
      "type": "object",
      "properties": {
        "checklistResults": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/ValidateChecklistResolutionResponse"
          }
        }
      }
    },
    "ChannelLocatorWithStatus": {
      "type": "object",
      "properties": {
        "channelLocator": {
          "$ref": "#/definitions/ChannelLocator"
        },
        "resolutionStatus": {
          "$ref": "#/definitions/ChannelResolutionStatus"
        }
      },
      "required": [
        "channelLocator",
        "resolutionStatus"
      ]
    },
    "ChannelResolutionStatus": {
      "type": "string",
      "enum": [
        "RESOLVED",
        "UNRESOLVED"
      ]
    },
    "CheckLiveStatusResponse": {
      "type": "object",
      "properties": {
        "status": {
          "$ref": "#/definitions/CheckStatus"
        },
        "checkRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "CheckRid"
        },
        "checkParameterIndex": {
          "type": "integer",
          "format": "int32",
          "description": "Checks can define a single range computation which can evaluate over multiple implementations of a context. The check implementation index will correspond to the implementation index of the check condition."
        }
      },
      "required": [
        "status",
        "checkRid"
      ]
    },
    "CheckStatus": {
      "type": "object",
      "x-union": true,
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "pass",
            "fail",
            "invalid",
            "skipped"
          ]
        },
        "pass": {
          "allOf": [
            {
              "$ref": "#/definitions/Pass"
            }
          ],
          "description": "The check was evaluated and is currently in state PASS."
        },
        "fail": {
          "allOf": [
            {
              "$ref": "#/definitions/Fail"
            }
          ],
          "description": "The check was evaluated and is currently in state FAIL."
        },
        "invalid": {
          "allOf": [
            {
              "$ref": "#/definitions/Invalid"
            }
          ],
          "description": "The check was evaluated and is currently in state INVALID. This signifies that the check could not be evaluated due to an internal error or if an overly expensive computation was attempted."
        },
        "skipped": {
          "allOf": [
            {
              "$ref": "#/definitions/Skipped"
            }
          ],
          "description": "The check was skipped and was not evaluated. This typically occurs when the check performs operations that are not supported in the streaming context, or if the required channels could not be resolved."
        }
      },
      "required": [
        "type"
      ],
      "description": "Set `type` to the name of one of the other fields, and set only that field.",
      "example": {
        "type": "pass",
        "pass": {}
      }
    },
    "ChecklistLiveStatus": {
      "type": "object",
      "x-union": true,
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "running",
            "initializing",
            "failed"
          ]
        },
        "running": {
          "allOf": [
            {
              "$ref": "#/definitions/StreamingChecklistRunning"
            }
          ],
          "description": "The streaming checklist is currently executing against the asset."
        },
        "initializing": {
          "allOf": [
            {
              "$ref": "#/definitions/StreamingChecklistInitializing"
            }
          ],
          "description": "The streaming checklist is currently initializing against the asset."
        },
        "failed": {
          "allOf": [
            {
              "$ref": "#/definitions/StreamingChecklistFailed"
            }
          ],
          "description": "The streaming checklist failed unexpectedly. Please contact support."
        }
      },
      "required": [
        "type"
      ],
      "description": "Set `type` to the name of one of the other fields, and set only that field.",
      "example": {
        "type": "running",
        "running": {
          "commitId": "string",
          "checkResults": [
            {
              "status": {
                "type": "pass",
                "pass": {}
              },
              "checkRid": "string",
              "checkParameterIndex": 1
            }
          ]
        }
      }
    },
    "ChecklistLiveStatusRequest": {
      "type": "object",
      "properties": {
        "checklistRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "ChecklistRid"
        },
        "assetRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "AssetRid"
        }
      },
      "required": [
        "checklistRid",
        "assetRid"
      ]
    },
    "ChecklistLiveStatusResponse": {
      "type": "object",
      "properties": {
        "checklistRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "ChecklistRid"
        },
        "assetRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "AssetRid"
        },
        "status": {
          "$ref": "#/definitions/ChecklistLiveStatus"
        }
      },
      "required": [
        "checklistRid",
        "assetRid",
        "status"
      ]
    },
    "ExecuteChecklistForAssetsRequest": {
      "type": "object",
      "properties": {
        "checklist": {
          "type": "string",
          "format": "rid",
          "x-alias": "ChecklistRid"
        },
        "assets": {
          "type": "array",
          "items": {
            "type": "string",
            "format": "rid",
            "x-alias": "AssetRid"
          },
          "uniqueItems": true
        },
        "notificationConfigurations": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/NotificationConfiguration"
          },
          "description": "Checklist violations will be sent to the specified integrations. If empty, no notifications will be sent."
        },
        "evaluationDelay": {
          "allOf": [
            {
              "$ref": "#/definitions/Duration"
            }
          ],
          "description": "Delays the evaluation of the streaming checklist. This is useful for when data is delayed."
        },
        "recoveryDelay": {
          "allOf": [
            {
              "$ref": "#/definitions/Duration"
            }
          ],
          "description": "Specifies the minimum amount of time that must pass before a check can recover from a failure. Minimum value is 15 seconds."
        },
        "autoCreateEvents": {
          "type": "boolean",
          "description": "The option to automatically create events for check status changes. If true, events will be created when checks fail and recover. Defaults to false if not specified."
        }
      },
      "required": [
        "checklist",
        "evaluationDelay",
        "recoveryDelay"
      ],
      "example": {
        "checklist": "<checklist rid>",
        "evaluationDelay": {
          "seconds": 1,
          "nanos": 1
        },
        "recoveryDelay": {
          "seconds": 1,
          "nanos": 1
        }
      }
    },
    "Fail": {
      "type": "object",
      "properties": {}
    },
    "Invalid": {
      "type": "object",
      "properties": {}
    },
    "InvalidStreamingComputeNode": {
      "type": "string",
      "enum": [
        "POINT_PERSISTENCE",
        "CUMULATIVE_SUM",
        "INTEGRAL",
        "STALENESS_DETECTION",
        "LITERAL_RANGES",
        "LITERAL_ENUM_SERIES",
        "TAG_BY_INTERVALS",
        "NUMERIC_COMBINE_WITH_TAGS",
        "PHASE_UNWRAP",
        "RUN_WITH_FIXED_END",
        "TIME_RANGE_FILTER_WITH_FIXED_END"
      ]
    },
    "ListStreamingChecklistForAssetRequest": {
      "type": "object",
      "properties": {
        "assetRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "AssetRid"
        },
        "pageSize": {
          "type": "integer",
          "format": "int32",
          "description": "Page sizes greater than 10_000 will be rejected. Default pageSize is 100."
        },
        "pageToken": {
          "type": "string",
          "format": "uuid"
        }
      },
      "required": [
        "assetRid"
      ],
      "example": {
        "assetRid": "<asset rid>"
      }
    },
    "ListStreamingChecklistForAssetResponse": {
      "type": "object",
      "properties": {
        "checklists": {
          "type": "array",
          "items": {
            "type": "string",
            "format": "rid",
            "x-alias": "ChecklistRid"
          }
        },
        "nextPageToken": {
          "type": "string",
          "format": "uuid"
        }
      }
    },
    "ListStreamingChecklistRequest": {
      "type": "object",
      "properties": {
        "pageSize": {
          "type": "integer",
          "format": "int32",
          "description": "Page sizes greater than 10_000 will be rejected. Default pageSize is 100."
        },
        "workspaces": {
          "type": "array",
          "items": {
            "type": "string",
            "format": "rid",
            "x-alias": "WorkspaceRid"
          },
          "uniqueItems": true
        },
        "pageToken": {
          "type": "string",
          "format": "uuid"
        }
      },
      "example": {
        "pageSize": 1,
        "workspaces": [
          "<workspace rid>"
        ],
        "pageToken": "<page token>"
      }
    },
    "ListStreamingChecklistResponse": {
      "type": "object",
      "properties": {
        "checklists": {
          "type": "array",
          "items": {
            "type": "string",
            "format": "rid",
            "x-alias": "ChecklistRid"
          }
        },
        "nextPageToken": {
          "type": "string",
          "format": "uuid"
        }
      }
    },
    "Pass": {
      "type": "object",
      "properties": {}
    },
    "ResolvedCheckStatus": {
      "description": "Provides the resolution status for the required channels for a check and the set of invalid streaming compute nodes present within the check's compute graph. Uniqueness between checkRid and checkParameterIndex pairs is guaranteed.",
      "type": "object",
      "properties": {
        "checkRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "CheckRid"
        },
        "checkParameterIndex": {
          "type": "integer",
          "format": "int32",
          "description": "Checks can define a single range computation which can evaluate over multiple implementations of a context. The check implementation index will correspond to the implementation index of the check condition."
        },
        "invalidStreamingComputeNodes": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/InvalidStreamingComputeNode"
          },
          "uniqueItems": true
        },
        "channels": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/ChannelLocatorWithStatus"
          },
          "uniqueItems": true
        },
        "resolutionError": {
          "allOf": [
            {
              "$ref": "#/definitions/SerializableError"
            }
          ],
          "description": "Why the check's compute graph could not be resolved. A streaming checklist skips this check."
        }
      },
      "required": [
        "checkRid"
      ]
    },
    "Skipped": {
      "type": "object",
      "properties": {}
    },
    "StopStreamingChecklistForAssetsRequest": {
      "type": "object",
      "properties": {
        "checklist": {
          "type": "string",
          "format": "rid",
          "x-alias": "ChecklistRid"
        },
        "assets": {
          "type": "array",
          "items": {
            "type": "string",
            "format": "rid",
            "x-alias": "AssetRid"
          },
          "uniqueItems": true
        }
      },
      "required": [
        "checklist"
      ],
      "example": {
        "checklist": "<checklist rid>"
      }
    },
    "StreamingChecklistFailed": {
      "type": "object",
      "properties": {}
    },
    "StreamingChecklistInfo": {
      "type": "object",
      "properties": {
        "checklistRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "ChecklistRid"
        },
        "assetConfigurations": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#/definitions/AssetStreamConfiguration"
          },
          "x-map-key": "AssetRid"
        }
      },
      "required": [
        "checklistRid"
      ]
    },
    "StreamingChecklistInitializing": {
      "type": "object",
      "properties": {}
    },
    "StreamingChecklistRunning": {
      "type": "object",
      "properties": {
        "commitId": {
          "type": "string",
          "x-alias": "CommitId",
          "description": "The commitId of the checklist that is currently executing."
        },
        "checkResults": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/CheckLiveStatusResponse"
          },
          "uniqueItems": true
        }
      },
      "required": [
        "commitId"
      ]
    },
    "ValidateChecklistResolutionRequest": {
      "description": "Validates that the channels referenced by the checklist can be resolved against the data sources. If commit is not provided, the latest commit on main will be used.",
      "type": "object",
      "properties": {
        "checklistRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "ChecklistRid"
        },
        "commitId": {
          "type": "string",
          "x-alias": "CommitId"
        },
        "assetRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "AssetRid"
        }
      },
      "required": [
        "checklistRid",
        "assetRid"
      ]
    },
    "ValidateChecklistResolutionResponse": {
      "type": "object",
      "properties": {
        "checklistRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "ChecklistRid"
        },
        "assetRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "AssetRid"
        },
        "resolutionStatus": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/ResolvedCheckStatus"
          },
          "uniqueItems": true
        }
      },
      "required": [
        "checklistRid",
        "assetRid"
      ]
    },
    "NotificationConfiguration": {
      "description": "Configuration details to send notifications to a linked integration.",
      "type": "object",
      "properties": {
        "integrationRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "IntegrationRid"
        },
        "notificationFilters": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/NotificationFilter"
          },
          "uniqueItems": true,
          "description": "Specifies the type of notifications to filter. If not provided, all notifications are sent."
        },
        "appendedWorkbookRid": {
          "type": "string",
          "format": "rid",
          "x-alias": "NotebookRid",
          "description": "If provided, appends a link to the workbook specified by the RID to the notification."
        },
        "tags": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "20 tags max, 50 characters max each. Tags are used to filter messages in Opsgenie. For other integrations, tags are ignored."
        },
        "muteUntil": {
          "type": "string",
          "format": "date-time",
          "description": "If provided, all notifications for this channel are suppressed until the specified time. The streaming checklist continues to evaluate, but no notifications are sent. Once the time has passed, notifications resume automatically."
        }
      },
      "required": [
        "integrationRid"
      ]
    },
    "NotificationFilter": {
      "description": "Specifies a type of notification to filter.",
      "type": "string",
      "enum": [
        "EXECUTION_ERROR"
      ]
    },
    "Duration": {
      "type": "object",
      "properties": {
        "seconds": {
          "type": "integer",
          "format": "int64"
        },
        "nanos": {
          "type": "integer",
          "format": "int64"
        }
      },
      "required": [
        "seconds",
        "nanos"
      ]
    }
  },
  "tags": [
    {
      "name": "Checklist Execution Service",
      "x-displayName": "Checklist execution service",
      "description": "The Checklist Execution Service checks the status of checklist executions.",
      "x-errors": [
        {
          "status": 400,
          "errorCode": "INVALID_ARGUMENT",
          "errorName": "ChecklistExecution:ChecklistAlreadyRunning"
        },
        {
          "status": 400,
          "errorCode": "INVALID_ARGUMENT",
          "errorName": "ChecklistExecution:CheckNotAvailableInStreamingContext"
        },
        {
          "status": 400,
          "errorCode": "INVALID_ARGUMENT",
          "errorName": "ChecklistExecution:ConnectionNotAvailableForStreaming"
        },
        {
          "status": 404,
          "errorCode": "NOT_FOUND",
          "errorName": "ChecklistExecution:StreamingChecklistNotFound"
        },
        {
          "status": 404,
          "errorCode": "NOT_FOUND",
          "errorName": "ChecklistExecution:StreamingChecklistNotFoundForAsset"
        }
      ]
    }
  ]
}