agent.openapi.json

{
  "openapi": "3.0.0",
  "info": {
    "title": "",
    "version": ""
  },
  "paths": {
    "/capabilities": {
      "get": {
        "responses": {
          "200": {
            "content": {
              "application/json;charset=utf-8": {
                "schema": {
                  "$ref": "#/components/schemas/CapabilitiesResponse"
                }
              }
            },
            "description": ""
          },
          "500": {
            "content": {
              "application/json;charset=utf-8": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": ""
          }
        }
      }
    },
    "/schema": {
      "get": {
        "parameters": [
          {
            "in": "header",
            "name": "X-Hasura-DataConnector-SourceName",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "header",
            "name": "X-Hasura-DataConnector-Config",
            "required": true,
            "schema": {
              "additionalProperties": true,
              "nullable": false,
              "type": "object"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json;charset=utf-8": {
                "schema": {
                  "$ref": "#/components/schemas/SchemaResponse"
                }
              }
            },
            "description": ""
          },
          "400": {
            "description": "Invalid `X-Hasura-DataConnector-Config` or `X-Hasura-DataConnector-SourceName`"
          },
          "500": {
            "content": {
              "application/json;charset=utf-8": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": ""
          }
        }
      }
    },
    "/query": {
      "post": {
        "parameters": [
          {
            "in": "header",
            "name": "X-Hasura-DataConnector-SourceName",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "header",
            "name": "X-Hasura-DataConnector-Config",
            "required": true,
            "schema": {
              "additionalProperties": true,
              "nullable": false,
              "type": "object"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json;charset=utf-8": {
              "schema": {
                "$ref": "#/components/schemas/QueryRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "content": {
              "application/json;charset=utf-8": {
                "schema": {
                  "$ref": "#/components/schemas/QueryResponse"
                }
              }
            },
            "description": ""
          },
          "400": {
            "description": "Invalid `body` or `X-Hasura-DataConnector-Config` or `X-Hasura-DataConnector-SourceName`"
          },
          "500": {
            "content": {
              "application/json;charset=utf-8": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": ""
          }
        }
      }
    },
    "/explain": {
      "post": {
        "parameters": [
          {
            "in": "header",
            "name": "X-Hasura-DataConnector-SourceName",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "header",
            "name": "X-Hasura-DataConnector-Config",
            "required": true,
            "schema": {
              "additionalProperties": true,
              "nullable": false,
              "type": "object"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json;charset=utf-8": {
              "schema": {
                "$ref": "#/components/schemas/QueryRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "content": {
              "application/json;charset=utf-8": {
                "schema": {
                  "$ref": "#/components/schemas/ExplainResponse"
                }
              }
            },
            "description": ""
          },
          "400": {
            "description": "Invalid `body` or `X-Hasura-DataConnector-Config` or `X-Hasura-DataConnector-SourceName`"
          }
        }
      }
    },
    "/health": {
      "get": {
        "parameters": [
          {
            "in": "header",
            "name": "X-Hasura-DataConnector-SourceName",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "header",
            "name": "X-Hasura-DataConnector-Config",
            "required": false,
            "schema": {
              "additionalProperties": true,
              "nullable": false,
              "type": "object"
            }
          }
        ],
        "responses": {
          "204": {
            "description": ""
          },
          "400": {
            "description": "Invalid `X-Hasura-DataConnector-Config` or `X-Hasura-DataConnector-SourceName`"
          }
        }
      }
    },
    "/metrics": {
      "get": {
        "responses": {
          "200": {
            "content": {
              "text/plain;version=0.0.4;charset=utf-8": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": ""
          }
        }
      }
    },
    "/raw": {
      "post": {
        "parameters": [
          {
            "in": "header",
            "name": "X-Hasura-DataConnector-SourceName",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "header",
            "name": "X-Hasura-DataConnector-Config",
            "required": true,
            "schema": {
              "additionalProperties": true,
              "nullable": false,
              "type": "object"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json;charset=utf-8": {
              "schema": {
                "$ref": "#/components/schemas/RawRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "content": {
              "application/json;charset=utf-8": {
                "schema": {
                  "$ref": "#/components/schemas/RawResponse"
                }
              }
            },
            "description": ""
          },
          "400": {
            "description": "Invalid `body` or `X-Hasura-DataConnector-Config` or `X-Hasura-DataConnector-SourceName`"
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "CapabilitiesResponse": {
        "nullable": false,
        "properties": {
          "capabilities": {
            "$ref": "#/components/schemas/Capabilities"
          },
          "config_schemas": {
            "$ref": "#/components/schemas/ConfigSchemaResponse"
          }
        },
        "required": [
          "capabilities",
          "config_schemas"
        ],
        "type": "object"
      },
      "Capabilities": {
        "properties": {
          "comparisons": {
            "$ref": "#/components/schemas/ComparisonCapabilities"
          },
          "data_schema": {
            "$ref": "#/components/schemas/DataSchemaCapabilities"
          },
          "explain": {
            "$ref": "#/components/schemas/ExplainCapabilities"
          },
          "metrics": {
            "$ref": "#/components/schemas/MetricsCapabilities"
          },
          "mutations": {
            "$ref": "#/components/schemas/MutationCapabilities"
          },
          "queries": {
            "$ref": "#/components/schemas/QueryCapabilities"
          },
          "raw": {
            "$ref": "#/components/schemas/RawCapabilities"
          },
          "relationships": {
            "$ref": "#/components/schemas/RelationshipCapabilities"
          },
          "scalar_types": {
            "$ref": "#/components/schemas/ScalarTypesCapabilities"
          },
          "subscriptions": {
            "$ref": "#/components/schemas/SubscriptionCapabilities"
          }
        },
        "type": "object"
      },
      "ColumnNullability": {
        "enum": [
          "only_nullable",
          "nullable_and_non_nullable"
        ],
        "type": "string"
      },
      "DataSchemaCapabilities": {
        "properties": {
          "column_nullability": {
            "$ref": "#/components/schemas/ColumnNullability"
          },
          "supports_foreign_keys": {
            "default": false,
            "description": "Whether tables can have foreign keys",
            "type": "boolean"
          },
          "supports_primary_keys": {
            "default": false,
            "description": "Whether tables can have primary keys",
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "QueryCapabilities": {},
      "MutationCapabilities": {},
      "SubscriptionCapabilities": {},
      "ScalarType": {
        "additionalProperties": true,
        "anyOf": [
          {
            "enum": [
              "string",
              "number",
              "bool"
            ],
            "type": "string"
          },
          {
            "type": "string"
          }
        ]
      },
      "ComparisonOperators": {
        "additionalProperties": {
          "$ref": "#/components/schemas/ScalarType"
        },
        "description": "A map from comparison operator names to their argument types.\nOperator and argument type names must be valid GraphQL names.\nResult type names must be defined scalar types - either builtin or declared in ScalarTypesCapabilities.\n",
        "type": "object"
      },
      "AggregateFunctions": {
        "additionalProperties": {
          "$ref": "#/components/schemas/ScalarType"
        },
        "description": "A map from aggregate function names to their result types.\nFunction and result type names must be valid GraphQL names.\nResult type names must be defined scalar types - either builtin or declared in ScalarTypesCapabilities.\n",
        "type": "object"
      },
      "ScalarTypeCapabilities": {
        "description": "Capabilities of a scalar type.\ncomparison_operators: The comparison operators supported by the scalar type.\naggregate_functions: The aggregate functions supported by the scalar type.\n",
        "properties": {
          "aggregate_functions": {
            "$ref": "#/components/schemas/AggregateFunctions"
          },
          "comparison_operators": {
            "$ref": "#/components/schemas/ComparisonOperators"
          }
        },
        "type": "object"
      },
      "ScalarTypesCapabilities": {
        "additionalProperties": {
          "$ref": "#/components/schemas/ScalarTypeCapabilities"
        },
        "description": "A map from scalar type names to their capabilities.\nKeys must be valid GraphQL names and must be defined as scalar types in the `graphql_schema`\n",
        "type": "object"
      },
      "RelationshipCapabilities": {},
      "SubqueryComparisonCapabilities": {
        "nullable": true,
        "properties": {
          "supports_relations": {
            "default": false,
            "description": "Does the agent support comparisons that involve related tables (ie. joins)?",
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "ComparisonCapabilities": {
        "properties": {
          "subquery": {
            "$ref": "#/components/schemas/SubqueryComparisonCapabilities"
          }
        },
        "type": "object"
      },
      "MetricsCapabilities": {},
      "ExplainCapabilities": {},
      "RawCapabilities": {},
      "ConfigSchemaResponse": {
        "nullable": false,
        "properties": {
          "config_schema": {
            "$ref": "#/components/schemas/OpenApiSchema"
          },
          "other_schemas": {
            "additionalProperties": {
              "$ref": "#/components/schemas/OpenApiSchema"
            },
            "nullable": false,
            "type": "object"
          }
        },
        "required": [
          "config_schema",
          "other_schemas"
        ],
        "type": "object"
      },
      "OpenApiSchema": {
        "additionalProperties": false,
        "properties": {
          "additionalProperties": {
            "additionalProperties": {
              "oneOf": [
                {
                  "$ref": "#/components/schemas/OpenApiSchema"
                },
                {
                  "$ref": "#/components/schemas/OpenApiReference"
                },
                {
                  "type": "boolean"
                }
              ]
            },
            "default": true
          },
          "allOf": {
            "items": {
              "oneOf": [
                {
                  "$ref": "#/components/schemas/OpenApiSchema"
                },
                {
                  "$ref": "#/components/schemas/OpenApiReference"
                }
              ]
            },
            "type": "array"
          },
          "anyOf": {
            "items": {
              "oneOf": [
                {
                  "$ref": "#/components/schemas/OpenApiSchema"
                },
                {
                  "$ref": "#/components/schemas/OpenApiReference"
                }
              ]
            },
            "type": "array"
          },
          "default": {},
          "deprecated": {
            "default": false,
            "type": "boolean"
          },
          "description": {
            "type": "string"
          },
          "discriminator": {
            "$ref": "#/components/schemas/OpenApiDiscriminator"
          },
          "enum": {
            "items": {},
            "minItems": 1,
            "type": "array",
            "uniqueItems": false
          },
          "example": {},
          "exclusiveMaximum": {
            "default": false,
            "type": "boolean"
          },
          "exclusiveMinimum": {
            "default": false,
            "type": "boolean"
          },
          "externalDocs": {
            "$ref": "#/components/schemas/OpenApiExternalDocumentation"
          },
          "format": {
            "type": "string"
          },
          "items": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/OpenApiSchema"
              },
              {
                "$ref": "#/components/schemas/OpenApiReference"
              }
            ]
          },
          "maxItems": {
            "minimum": 0,
            "type": "integer"
          },
          "maxLength": {
            "minimum": 0,
            "type": "integer"
          },
          "maxProperties": {
            "minimum": 0,
            "type": "integer"
          },
          "maximum": {
            "type": "number"
          },
          "minItems": {
            "default": 0,
            "minimum": 0,
            "type": "integer"
          },
          "minLength": {
            "default": 0,
            "minimum": 0,
            "type": "integer"
          },
          "minProperties": {
            "default": 0,
            "minimum": 0,
            "type": "integer"
          },
          "minimum": {
            "type": "number"
          },
          "multipleOf": {
            "exclusiveMinimum": true,
            "minimum": 0,
            "type": "number"
          },
          "not": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/OpenApiSchema"
              },
              {
                "$ref": "#/components/schemas/OpenApiReference"
              }
            ]
          },
          "nullable": {
            "default": false,
            "type": "boolean"
          },
          "oneOf": {
            "items": {
              "oneOf": [
                {
                  "$ref": "#/components/schemas/OpenApiSchema"
                },
                {
                  "$ref": "#/components/schemas/OpenApiReference"
                }
              ]
            },
            "type": "array"
          },
          "pattern": {
            "format": "regex",
            "type": "string"
          },
          "properties": {
            "additionalProperties": {
              "oneOf": [
                {
                  "$ref": "#/components/schemas/OpenApiSchema"
                },
                {
                  "$ref": "#/components/schemas/OpenApiReference"
                }
              ]
            },
            "type": "object"
          },
          "readOnly": {
            "default": false,
            "type": "boolean"
          },
          "required": {
            "items": {
              "type": "string"
            },
            "minItems": 1,
            "type": "array",
            "uniqueItems": true
          },
          "title": {
            "type": "string"
          },
          "type": {
            "enum": [
              "array",
              "boolean",
              "integer",
              "number",
              "object",
              "string"
            ],
            "type": "string"
          },
          "uniqueItems": {
            "default": false,
            "type": "boolean"
          },
          "writeOnly": {
            "default": false,
            "type": "boolean"
          },
          "xml": {
            "$ref": "#/components/schemas/OpenApiXml"
          }
        },
        "type": "object"
      },
      "OpenApiReference": {
        "properties": {
          "$ref": {
            "format": "uri-reference",
            "type": "string"
          }
        },
        "required": [
          "$ref"
        ],
        "type": "object"
      },
      "OpenApiDiscriminator": {
        "properties": {
          "mapping": {
            "additionalProperties": {
              "type": "string"
            },
            "type": "object"
          },
          "propertyName": {
            "type": "string"
          }
        },
        "required": [
          "propertyName"
        ],
        "type": "object"
      },
      "OpenApiExternalDocumentation": {
        "additionalProperties": false,
        "properties": {
          "description": {
            "type": "string"
          },
          "url": {
            "format": "uri-reference",
            "type": "string"
          }
        },
        "required": [
          "url"
        ],
        "type": "object"
      },
      "OpenApiXml": {
        "additionalProperties": false,
        "properties": {
          "attribute": {
            "default": false,
            "type": "boolean"
          },
          "name": {
            "type": "string"
          },
          "namespace": {
            "format": "uri",
            "type": "string"
          },
          "prefix": {
            "type": "string"
          },
          "wrapped": {
            "default": false,
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "ErrorResponse": {
        "properties": {
          "details": {
            "additionalProperties": true,
            "default": null,
            "description": "Error details"
          },
          "message": {
            "description": "Error message",
            "type": "string"
          },
          "type": {
            "$ref": "#/components/schemas/ErrorResponseType"
          }
        },
        "required": [
          "message"
        ],
        "type": "object"
      },
      "ErrorResponseType": {
        "enum": [
          "uncaught-error"
        ],
        "type": "string"
      },
      "SchemaResponse": {
        "properties": {
          "tables": {
            "description": "Available tables",
            "items": {
              "$ref": "#/components/schemas/TableInfo"
            },
            "type": "array"
          }
        },
        "required": [
          "tables"
        ],
        "type": "object"
      },
      "TableName": {
        "description": "The fully qualified name of a table, where the last item in the array is the table name and any earlier items represent the namespacing of the table name",
        "items": {
          "type": "string"
        },
        "type": "array"
      },
      "ColumnInfo": {
        "properties": {
          "description": {
            "description": "Column description",
            "nullable": true,
            "type": "string"
          },
          "name": {
            "description": "Column name",
            "type": "string"
          },
          "nullable": {
            "description": "Is column nullable",
            "type": "boolean"
          },
          "type": {
            "$ref": "#/components/schemas/ScalarType"
          }
        },
        "required": [
          "name",
          "type",
          "nullable"
        ],
        "type": "object"
      },
      "Constraint": {
        "properties": {
          "column_mapping": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "The columns on which you want want to define the foreign key.",
            "type": "object"
          },
          "foreign_table": {
            "$ref": "#/components/schemas/TableName"
          }
        },
        "required": [
          "foreign_table",
          "column_mapping"
        ],
        "type": "object"
      },
      "TableInfo": {
        "properties": {
          "columns": {
            "description": "The columns of the table",
            "items": {
              "$ref": "#/components/schemas/ColumnInfo"
            },
            "type": "array"
          },
          "description": {
            "description": "Description of the table",
            "nullable": true,
            "type": "string"
          },
          "foreign_keys": {
            "additionalProperties": {
              "$ref": "#/components/schemas/Constraint"
            },
            "default": {},
            "description": "Foreign key constraints",
            "type": "object"
          },
          "name": {
            "$ref": "#/components/schemas/TableName"
          },
          "primary_key": {
            "default": [],
            "description": "The primary key of the table",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "name",
          "columns"
        ],
        "type": "object"
      },
      "QueryResponse": {
        "properties": {
          "aggregates": {
            "additionalProperties": {
              "additionalProperties": true
            },
            "description": "The results of the aggregates returned by the query",
            "nullable": true,
            "type": "object"
          },
          "rows": {
            "description": "The rows returned by the query, corresponding to the query's fields",
            "items": {
              "additionalProperties": {
                "additionalProperties": true,
                "anyOf": [
                  {
                    "$ref": "#/components/schemas/ColumnFieldValue"
                  },
                  {
                    "$ref": "#/components/schemas/QueryResponse"
                  },
                  {
                    "$ref": "#/components/schemas/NullColumnFieldValue"
                  }
                ]
              },
              "type": "object"
            },
            "nullable": true,
            "type": "array"
          }
        },
        "type": "object"
      },
      "ColumnFieldValue": {
        "additionalProperties": true
      },
      "NullColumnFieldValue": {
        "type": "null"
      },
      "QueryRequest": {
        "properties": {
          "query": {
            "$ref": "#/components/schemas/Query"
          },
          "table": {
            "$ref": "#/components/schemas/TableName"
          },
          "table_relationships": {
            "description": "The relationships between tables involved in the entire query request",
            "items": {
              "$ref": "#/components/schemas/TableRelationships"
            },
            "type": "array"
          }
        },
        "required": [
          "table",
          "table_relationships",
          "query"
        ],
        "type": "object"
      },
      "RelationshipType": {
        "enum": [
          "object",
          "array"
        ],
        "type": "string"
      },
      "Relationship": {
        "properties": {
          "column_mapping": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "A mapping between columns on the source table to columns on the target table",
            "type": "object"
          },
          "relationship_type": {
            "$ref": "#/components/schemas/RelationshipType"
          },
          "target_table": {
            "$ref": "#/components/schemas/TableName"
          }
        },
        "required": [
          "target_table",
          "relationship_type",
          "column_mapping"
        ],
        "type": "object"
      },
      "TableRelationships": {
        "properties": {
          "relationships": {
            "additionalProperties": {
              "$ref": "#/components/schemas/Relationship"
            },
            "description": "A map of relationships from the source table to target tables. The key of the map is the relationship name",
            "type": "object"
          },
          "source_table": {
            "$ref": "#/components/schemas/TableName"
          }
        },
        "required": [
          "source_table",
          "relationships"
        ],
        "type": "object"
      },
      "Query": {
        "properties": {
          "aggregates": {
            "additionalProperties": {
              "$ref": "#/components/schemas/Aggregate"
            },
            "description": "Aggregate fields of the query",
            "nullable": true,
            "type": "object"
          },
          "fields": {
            "additionalProperties": {
              "$ref": "#/components/schemas/Field"
            },
            "description": "Fields of the query",
            "nullable": true,
            "type": "object"
          },
          "limit": {
            "description": "Optionally limit to N results",
            "maximum": 9223372036854776000,
            "minimum": -9223372036854776000,
            "nullable": true,
            "type": "number"
          },
          "offset": {
            "description": "Optionally offset from the Nth result",
            "maximum": 9223372036854776000,
            "minimum": -9223372036854776000,
            "nullable": true,
            "type": "number"
          },
          "order_by": {
            "$ref": "#/components/schemas/OrderBy"
          },
          "where": {
            "$ref": "#/components/schemas/Expression"
          }
        },
        "type": "object"
      },
      "RelationshipField": {
        "properties": {
          "query": {
            "$ref": "#/components/schemas/Query"
          },
          "relationship": {
            "description": "The name of the relationship to follow for the subquery",
            "type": "string"
          },
          "type": {
            "enum": [
              "relationship"
            ],
            "type": "string"
          }
        },
        "required": [
          "relationship",
          "query",
          "type"
        ],
        "type": "object"
      },
      "ColumnField": {
        "properties": {
          "column": {
            "type": "string"
          },
          "column_type": {
            "$ref": "#/components/schemas/ScalarType"
          },
          "type": {
            "enum": [
              "column"
            ],
            "type": "string"
          }
        },
        "required": [
          "column",
          "column_type",
          "type"
        ],
        "type": "object"
      },
      "Field": {
        "discriminator": {
          "mapping": {
            "column": "ColumnField",
            "relationship": "RelationshipField"
          },
          "propertyName": "type"
        },
        "oneOf": [
          {
            "$ref": "#/components/schemas/RelationshipField"
          },
          {
            "$ref": "#/components/schemas/ColumnField"
          }
        ]
      },
      "ColumnCountAggregate": {
        "properties": {
          "column": {
            "description": "The column to apply the count aggregate function to",
            "type": "string"
          },
          "distinct": {
            "description": "Whether or not only distinct items should be counted",
            "type": "boolean"
          },
          "type": {
            "enum": [
              "column_count"
            ],
            "type": "string"
          }
        },
        "required": [
          "column",
          "distinct",
          "type"
        ],
        "type": "object"
      },
      "SingleColumnAggregateFunction": {
        "description": "Single column aggregate function name.\nA valid GraphQL name",
        "type": "string"
      },
      "SingleColumnAggregate": {
        "properties": {
          "column": {
            "description": "The column to apply the aggregation function to",
            "type": "string"
          },
          "function": {
            "$ref": "#/components/schemas/SingleColumnAggregateFunction"
          },
          "type": {
            "enum": [
              "single_column"
            ],
            "type": "string"
          }
        },
        "required": [
          "function",
          "column",
          "type"
        ],
        "type": "object"
      },
      "StarCountAggregate": {
        "properties": {
          "type": {
            "enum": [
              "star_count"
            ],
            "type": "string"
          }
        },
        "required": [
          "type"
        ],
        "type": "object"
      },
      "Aggregate": {
        "discriminator": {
          "mapping": {
            "column_count": "ColumnCountAggregate",
            "single_column": "SingleColumnAggregate",
            "star_count": "StarCountAggregate"
          },
          "propertyName": "type"
        },
        "oneOf": [
          {
            "$ref": "#/components/schemas/ColumnCountAggregate"
          },
          {
            "$ref": "#/components/schemas/SingleColumnAggregate"
          },
          {
            "$ref": "#/components/schemas/StarCountAggregate"
          }
        ]
      },
      "UnrelatedTable": {
        "properties": {
          "table": {
            "$ref": "#/components/schemas/TableName"
          },
          "type": {
            "enum": [
              "unrelated"
            ],
            "type": "string"
          }
        },
        "required": [
          "table",
          "type"
        ],
        "type": "object"
      },
      "RelatedTable": {
        "properties": {
          "relationship": {
            "type": "string"
          },
          "type": {
            "enum": [
              "related"
            ],
            "type": "string"
          }
        },
        "required": [
          "relationship",
          "type"
        ],
        "type": "object"
      },
      "ExistsInTable": {
        "discriminator": {
          "mapping": {
            "related": "RelatedTable",
            "unrelated": "UnrelatedTable"
          },
          "propertyName": "type"
        },
        "oneOf": [
          {
            "$ref": "#/components/schemas/UnrelatedTable"
          },
          {
            "$ref": "#/components/schemas/RelatedTable"
          }
        ]
      },
      "Expression": {
        "discriminator": {
          "mapping": {
            "and": "AndExpression",
            "binary_arr_op": "ApplyBinaryArrayComparisonOperator",
            "binary_op": "ApplyBinaryComparisonOperator",
            "exists": "ExistsExpression",
            "not": "NotExpression",
            "or": "OrExpression",
            "unary_op": "ApplyUnaryComparisonOperator"
          },
          "propertyName": "type"
        },
        "oneOf": [
          {
            "$ref": "#/components/schemas/ExistsExpression"
          },
          {
            "$ref": "#/components/schemas/ApplyBinaryArrayComparisonOperator"
          },
          {
            "$ref": "#/components/schemas/OrExpression"
          },
          {
            "$ref": "#/components/schemas/ApplyUnaryComparisonOperator"
          },
          {
            "$ref": "#/components/schemas/ApplyBinaryComparisonOperator"
          },
          {
            "$ref": "#/components/schemas/NotExpression"
          },
          {
            "$ref": "#/components/schemas/AndExpression"
          }
        ]
      },
      "ExistsExpression": {
        "properties": {
          "in_table": {
            "$ref": "#/components/schemas/ExistsInTable"
          },
          "type": {
            "enum": [
              "exists"
            ],
            "type": "string"
          },
          "where": {
            "$ref": "#/components/schemas/Expression"
          }
        },
        "required": [
          "in_table",
          "where",
          "type"
        ],
        "type": "object"
      },
      "BinaryArrayComparisonOperator": {
        "additionalProperties": true,
        "anyOf": [
          {
            "enum": [
              "in"
            ],
            "type": "string"
          },
          {
            "type": "string"
          }
        ]
      },
      "ComparisonColumn": {
        "properties": {
          "column_type": {
            "$ref": "#/components/schemas/ScalarType"
          },
          "name": {
            "description": "The name of the column",
            "type": "string"
          },
          "path": {
            "default": [],
            "description": "The path to the table that contains the specified column. Missing or empty array means the current table. [\"$\"] means the query table. No other values are supported at this time.",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "name",
          "column_type"
        ],
        "type": "object"
      },
      "ApplyBinaryArrayComparisonOperator": {
        "properties": {
          "column": {
            "$ref": "#/components/schemas/ComparisonColumn"
          },
          "operator": {
            "$ref": "#/components/schemas/BinaryArrayComparisonOperator"
          },
          "type": {
            "enum": [
              "binary_arr_op"
            ],
            "type": "string"
          },
          "value_type": {
            "$ref": "#/components/schemas/ScalarType"
          },
          "values": {
            "items": {
              "additionalProperties": true
            },
            "type": "array"
          }
        },
        "required": [
          "operator",
          "column",
          "values",
          "value_type",
          "type"
        ],
        "type": "object"
      },
      "OrExpression": {
        "properties": {
          "expressions": {
            "items": {
              "$ref": "#/components/schemas/Expression"
            },
            "type": "array"
          },
          "type": {
            "enum": [
              "or"
            ],
            "type": "string"
          }
        },
        "required": [
          "expressions",
          "type"
        ],
        "type": "object"
      },
      "UnaryComparisonOperator": {
        "additionalProperties": true,
        "anyOf": [
          {
            "enum": [
              "is_null"
            ],
            "type": "string"
          },
          {
            "type": "string"
          }
        ]
      },
      "ApplyUnaryComparisonOperator": {
        "properties": {
          "column": {
            "$ref": "#/components/schemas/ComparisonColumn"
          },
          "operator": {
            "$ref": "#/components/schemas/UnaryComparisonOperator"
          },
          "type": {
            "enum": [
              "unary_op"
            ],
            "type": "string"
          }
        },
        "required": [
          "operator",
          "column",
          "type"
        ],
        "type": "object"
      },
      "BinaryComparisonOperator": {
        "additionalProperties": true,
        "anyOf": [
          {
            "enum": [
              "less_than",
              "less_than_or_equal",
              "greater_than",
              "greater_than_or_equal",
              "equal"
            ],
            "type": "string"
          },
          {
            "type": "string"
          }
        ]
      },
      "ScalarValueComparison": {
        "properties": {
          "type": {
            "enum": [
              "scalar"
            ],
            "type": "string"
          },
          "value": {
            "additionalProperties": true
          },
          "value_type": {
            "$ref": "#/components/schemas/ScalarType"
          }
        },
        "required": [
          "value",
          "value_type",
          "type"
        ],
        "type": "object"
      },
      "AnotherColumnComparison": {
        "properties": {
          "column": {
            "$ref": "#/components/schemas/ComparisonColumn"
          },
          "type": {
            "enum": [
              "column"
            ],
            "type": "string"
          }
        },
        "required": [
          "column",
          "type"
        ],
        "type": "object"
      },
      "ComparisonValue": {
        "discriminator": {
          "mapping": {
            "column": "AnotherColumnComparison",
            "scalar": "ScalarValueComparison"
          },
          "propertyName": "type"
        },
        "oneOf": [
          {
            "$ref": "#/components/schemas/ScalarValueComparison"
          },
          {
            "$ref": "#/components/schemas/AnotherColumnComparison"
          }
        ]
      },
      "ApplyBinaryComparisonOperator": {
        "properties": {
          "column": {
            "$ref": "#/components/schemas/ComparisonColumn"
          },
          "operator": {
            "$ref": "#/components/schemas/BinaryComparisonOperator"
          },
          "type": {
            "enum": [
              "binary_op"
            ],
            "type": "string"
          },
          "value": {
            "$ref": "#/components/schemas/ComparisonValue"
          }
        },
        "required": [
          "operator",
          "column",
          "value",
          "type"
        ],
        "type": "object"
      },
      "NotExpression": {
        "properties": {
          "expression": {
            "$ref": "#/components/schemas/Expression"
          },
          "type": {
            "enum": [
              "not"
            ],
            "type": "string"
          }
        },
        "required": [
          "expression",
          "type"
        ],
        "type": "object"
      },
      "AndExpression": {
        "properties": {
          "expressions": {
            "items": {
              "$ref": "#/components/schemas/Expression"
            },
            "type": "array"
          },
          "type": {
            "enum": [
              "and"
            ],
            "type": "string"
          }
        },
        "required": [
          "expressions",
          "type"
        ],
        "type": "object"
      },
      "OrderByRelation": {
        "properties": {
          "subrelations": {
            "additionalProperties": {
              "$ref": "#/components/schemas/OrderByRelation"
            },
            "description": "Further relationships to follow from the relationship's target table. The key of the map is the relationship name.",
            "type": "object"
          },
          "where": {
            "$ref": "#/components/schemas/Expression"
          }
        },
        "required": [
          "subrelations"
        ],
        "type": "object"
      },
      "OrderByStarCountAggregate": {
        "properties": {
          "type": {
            "enum": [
              "star_count_aggregate"
            ],
            "type": "string"
          }
        },
        "required": [
          "type"
        ],
        "type": "object"
      },
      "OrderBySingleColumnAggregate": {
        "properties": {
          "column": {
            "description": "The column to apply the aggregation function to",
            "type": "string"
          },
          "function": {
            "$ref": "#/components/schemas/SingleColumnAggregateFunction"
          },
          "type": {
            "enum": [
              "single_column_aggregate"
            ],
            "type": "string"
          }
        },
        "required": [
          "function",
          "column",
          "type"
        ],
        "type": "object"
      },
      "OrderByColumn": {
        "properties": {
          "column": {
            "type": "string"
          },
          "type": {
            "enum": [
              "column"
            ],
            "type": "string"
          }
        },
        "required": [
          "column",
          "type"
        ],
        "type": "object"
      },
      "OrderByTarget": {
        "discriminator": {
          "mapping": {
            "column": "OrderByColumn",
            "single_column_aggregate": "OrderBySingleColumnAggregate",
            "star_count_aggregate": "OrderByStarCountAggregate"
          },
          "propertyName": "type"
        },
        "oneOf": [
          {
            "$ref": "#/components/schemas/OrderByStarCountAggregate"
          },
          {
            "$ref": "#/components/schemas/OrderBySingleColumnAggregate"
          },
          {
            "$ref": "#/components/schemas/OrderByColumn"
          }
        ]
      },
      "OrderDirection": {
        "enum": [
          "asc",
          "desc"
        ],
        "type": "string"
      },
      "OrderByElement": {
        "properties": {
          "order_direction": {
            "$ref": "#/components/schemas/OrderDirection"
          },
          "target": {
            "$ref": "#/components/schemas/OrderByTarget"
          },
          "target_path": {
            "description": "The relationship path from the current query table to the table that contains the target to order by. This is always non-empty for aggregate order by targets",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "target_path",
          "target",
          "order_direction"
        ],
        "type": "object"
      },
      "OrderBy": {
        "nullable": true,
        "properties": {
          "elements": {
            "description": "The elements to order by, in priority order",
            "items": {
              "$ref": "#/components/schemas/OrderByElement"
            },
            "type": "array"
          },
          "relations": {
            "additionalProperties": {
              "$ref": "#/components/schemas/OrderByRelation"
            },
            "description": "A map of relationships from the current query table to target tables. The key of the map is the relationship name. The relationships are used within the order by elements.",
            "type": "object"
          }
        },
        "required": [
          "relations",
          "elements"
        ],
        "type": "object"
      },
      "ExplainResponse": {
        "properties": {
          "lines": {
            "description": "Lines of the formatted explain plan response",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "query": {
            "description": "The generated query - i.e. SQL for a relational DB",
            "type": "string"
          }
        },
        "required": [
          "lines",
          "query"
        ],
        "type": "object"
      },
      "RawResponse": {
        "properties": {
          "rows": {
            "description": "The rows returned by the raw query.",
            "items": {
              "additionalProperties": {
                "additionalProperties": true
              },
              "type": "object"
            },
            "type": "array"
          }
        },
        "required": [
          "rows"
        ],
        "type": "object"
      },
      "RawRequest": {
        "properties": {
          "query": {
            "description": "A string representing a raw query",
            "type": "string"
          }
        },
        "required": [
          "query"
        ],
        "type": "object"
      }
    }
  }
}