OGC API - Features - Part 3: Filtering and the Common Query Language (CQL)

http://www.someserver.com/ogcapi/search?
  collections=collection1,collection3&
  filter-lang=cql-text&
  filter=prop1=10 AND prop2>45

{
   "$schema": "https://json-schema.org/draft/2019-09/schema",
   "type": "object",
   "oneOf": [
      {"$ref": "#/$defs/andExpression"},
      {"$ref": "#/$defs/orExpression"},
      {"$ref": "#/$defs/notExpression"},
      {"$ref": "#/$defs/comparisonPredicate"},
      {"$ref": "#/$defs/spatialPredicate"},
      {"$ref": "#/$defs/temporalPredicate"},
      {"$ref": "#/$defs/arrayPredicate"}
   ],
   "$recursiveAnchor": true,
   "$defs": {
      "$comment": "=======================================================",
      "$comment": "=  BOOLEAN VALUE EXPRESSION                           =",
      "$comment": "=======================================================",

      "andExpression": {
         "type": "object",
         "required": ["and"],
         "properties": {
            "and": {
               "type": "array",
               "minItems": 2,
               "items": {
                  "$recursiveRef": "#"
               }
            }
         }
      },

      "orExpression": {
         "type": "object",
         "required": ["or"],
         "properties": {
            "or": {
               "type": "array",
               "minItems": 2,
               "items": {
                  "$recursiveRef": "#"
               }
            }
         }
      },

      "notExpression": {
         "type": "object",
         "required": ["not"],
         "properties": {
            "not": {
               "type": "array",
               "minItems": 1,
               "maxItems": 1,
               "items": {
                  "$recursiveRef": "#"
               }
            }
         }
      },

      "$comment": "=======================================================",
      "$comment": "=  COMPARISON PREDICATES                              =",
      "$comment": "=======================================================",

      "comparisonPredicate" : {
         "oneOf": [
            {"$ref": "#/$defs/binaryComparisonPredicate"},
            {"$ref": "#/$defs/isLikePredicate" },
            {"$ref": "#/$defs/isBetweenPredicate"},
            {"$ref": "#/$defs/isInListPredicate" },
            {"$ref": "#/$defs/isNullPredicate" }
         ]
      },

      "binaryComparisonPredicate": {
         "oneOf": [
            { "$ref": "#/$defs/eqExpression" },
            { "$ref": "#/$defs/ltExpression" },
            { "$ref": "#/$defs/gtExpression" },
            { "$ref": "#/$defs/lteExpression" },
            { "$ref": "#/$defs/gteExpression" }
         ]
      },

      "eqExpression": {
         "type": "object",
         "required": ["eq"],
         "properties": {
            "eq": { "$ref": "#/$defs/scalarOperands" }
         }
      },

      "ltExpression": {
         "type": "object",
           "required": ["lt"],
           "properties": {
              "lt": { "$ref": "#/$defs/scalarOperands" }
         }
      },

      "gtExpression": {
         "type": "object",
         "required": ["gt"],
         "properties": {
            "gt": { "$ref": "#/$defs/scalarOperands" }
         }
      },

      "lteExpression": {
         "type": "object",
         "required": ["lte"],
         "properties": {
            "lte": { "$ref": "#/$defs/scalarOperands" }
         }
      },

      "gteExpression": {
         "type": "object",
         "required": ["gte"],
         "properties": {
            "gte": { "$ref": "#/$defs/scalarOperands" }
         }
      },

      "isBetweenPredicate": {
         "type": "object",
         "required": ["between"],
         "properties": {
            "between": {
               "type": "object",
               "required" : [ "value", "lower", "upper" ],
               "properties": {
                  "value": { "$ref": "#/$defs/valueExpression" },
                  "lower": { "$ref": "#/$defs/scalarExpression" },
                  "upper": { "$ref": "#/$defs/scalarExpression" }
               }
            }
         }
      },

      "isLikePredicate": {
         "type": "object",
         "required": ["like"],
         "properties": {
            "like": { "$ref": "#/$defs/scalarOperands" },
            "wildcard": { "type": "string", "default": "%" },
            "singleChar": { "type": "string", "default": "." },
            "escapeChar": { "type": "string", "default": "\\" },
            "nocase": { "type": "boolean", "default": true }
         }
      },

      "isInListPredicate": {
         "type": "object",
         "required": ["in"],
         "properties": {
            "in": {
               "type": "object",
               "required": ["value","list"],
               "properties": {
                  "value": { "$ref": "#/$defs/valueExpression" },
                  "list": {
                     "type": "array",
                     "items": {
                        "$ref": "#/$defs/valueExpression"
                     }
                  },
                  "nocase": {
                     "type": "boolean",
                     "default": true
                  }
               }
            }
         }
      },

      "valueExpression": {
         "oneOf": [
            {"$ref": "#/$defs/scalarExpression"},
            {"$ref": "#/$defs/spatialLiteral"},
            {"$ref": "#/$defs/typedTemporalLiteral"}
         ]
      },

      "scalarOperands": {
         "type": "array",
         "minItems": 2,
         "maxItems": 2,
         "items": {
            "$ref": "#/$defs/scalarExpression"
         }
      },

      "scalarExpression": {
         "oneOf": [
            {"$ref": "#/$defs/scalarLiteral"},
            {"$ref": "#/$defs/propertyRef"},
            {"$ref": "#/$defs/functionRef"},
            {"$ref": "#/$defs/arithmeticExpression"}
         ]
      },

      "isNullPredicate": {
         "type": "object",
         "required": [ "isNull" ],
         "properties": {
            "isNull": {
               "$ref": "#/$defs/scalarExpression"
            }
         }
      },

      "$comment": "=======================================================",
      "$comment": "=  SPATIAL PREDICATES                                 =",
      "$comment": "=======================================================",

      "spatialPredicate" : {
         "oneOf": [
           {"$ref": "#/$defs/intersectsExpression"},
           {"$ref": "#/$defs/equalsExpression"},
           {"$ref": "#/$defs/disjointExpression"},
           {"$ref": "#/$defs/touchesExpression"},
           {"$ref": "#/$defs/withinExpression"},
           {"$ref": "#/$defs/overlapsExpression"},
           {"$ref": "#/$defs/crossesExpression"},
           {"$ref": "#/$defs/containsExpression"}
         ]
      },

      "intersectsExpression": {
         "type": "object",
         "required": ["intersects"],
         "properties": {
            "intersects": { "$ref": "#/$defs/spatialOperands" }
         }
      },

      "equalsExpression": {
         "type": "object",
         "required": ["equals"],
         "properties": {
            "equals": { "$ref": "#/$defs/spatialOperands" }
         }
      },

      "disjointExpression": {
         "type": "object",
         "required": ["disjoint"],
         "properties": {
            "disjoint": { "$ref": "#/$defs/spatialOperands" }
         }
      },

      "touchesExpression": {
         "type": "object",
         "required": ["touches"],
         "properties": {
            "touches": { "$ref": "#/$defs/spatialOperands" }
         }
      },

      "withinExpression": {
         "type": "object",
         "required": ["within"],
         "properties": {
            "within": { "$ref": "#/$defs/spatialOperands" }
         }
      },

      "overlapsExpression": {
         "type": "object",
         "required": ["overlaps"],
         "properties": {
            "overlaps": { "$ref": "#/$defs/spatialOperands" }
         }
      },

      "crossesExpression": {
         "type": "object",
         "required": ["crosses"],
         "properties": {
            "crosses": { "$ref": "#/$defs/spatialOperands" }
         }
      },

      "containsExpression": {
         "type": "object",
         "required": ["contains"],
         "properties": {
            "contains": { "$ref": "#/$defs/spatialOperands" }
         }
      },

      "spatialOperands": {
         "type": "array",
         "minItems": 2,
         "maxItems": 2,
         "items": {
            "$ref": "#/$defs/geomExpression"
         }
      },

      "geomExpression": {
         "oneOf": [
            {"$ref": "#/$defs/spatialLiteral"},
            {"$ref": "#/$defs/propertyRef"},
            {"$ref": "#/$defs/functionRef"}
         ]
      },

      "$comment": "=======================================================",
      "$comment": "=  TEMPORAL EXPRESSIONS                               =",
      "$comment": "=======================================================",

      "temporalPredicate" : {
         "oneOf": [
           {"$ref": "#/$defs/beforeExpression"},
           {"$ref": "#/$defs/afterExpression"},
           {"$ref": "#/$defs/meetsExpression"},
           {"$ref": "#/$defs/metbyExpression"},
           {"$ref": "#/$defs/toverlapsExpression"},
           {"$ref": "#/$defs/overlappedbyExpression"},
           {"$ref": "#/$defs/beginsExpression"},
           {"$ref": "#/$defs/begunbyExpression"},
           {"$ref": "#/$defs/duringExpression"},
           {"$ref": "#/$defs/tcontainsExpression"},
           {"$ref": "#/$defs/endsExpression"},
           {"$ref": "#/$defs/endedbyExpression"},
           {"$ref": "#/$defs/tequalsExpression"},
           {"$ref": "#/$defs/anyinteractsExpression"}
         ]
      },

      "beforeExpression": {
         "type": "object",
         "required": ["before"],
         "properties": {
            "before": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "afterExpression": {
         "type": "object",
         "required": ["after"],
         "properties": {
            "after": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "meetsExpression": {
         "type": "object",
         "required": ["meets"],
         "properties": {
            "meets": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "metbyExpression": {
         "type": "object",
         "required": ["metby"],
         "properties": {
            "metby": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "toverlapsExpression": {
         "type": "object",
         "required": ["toverlaps"],
         "properties": {
            "toverlaps": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "overlappedbyExpression": {
         "type": "object",
         "required": ["overlappedby"],
         "properties": {
            "overlappedby": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "beginsExpression": {
         "type": "object",
         "required": ["begins"],
         "properties": {
            "begins": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "begunbyExpression": {
         "type": "object",
         "required": ["begunby"],
         "properties": {
            "begunby": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "duringExpression": {
         "type": "object",
         "required": ["during"],
         "properties": {
            "during": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "tcontainsExpression": {
         "type": "object",
         "required": ["tcontains"],
         "properties": {
            "tcontains": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "endsExpression": {
         "type": "object",
         "required": ["ends"],
         "properties": {
            "ends": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "endedbyExpression": {
         "type": "object",
         "required": ["endedby"],
         "properties": {
            "endedby": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "tequalsExpression": {
         "type": "object",
         "required": ["tequals"],
         "properties": {
            "tequals": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "anyinteractsExpression": {
         "type": "object",
         "required": ["anyinteracts"],
         "properties": {
            "anyinteracts": { "$ref": "#/$defs/temporalOperands" }
         }
      },

      "temporalOperands": {
         "type": "array",
         "minItems": 2,
         "maxItems": 2,
         "items": {
            "$ref": "#/$defs/temporalExpression"
         }
      },

      "temporalExpression": {
         "oneOf": [
            {"$ref": "#/$defs/temporalLiteral"},
            {"$ref": "#/$defs/propertyRef"},
            {"$ref": "#/$defs/functionRef"}
         ]
      },

      "$comment": "=======================================================",
      "$comment": "=  ARRAY PREDICATE                                    =",
      "$comment": "=======================================================",

      "arrayPredicate" : {
         "oneOf": [
            {"$ref": "#/$defs/aequalsExpression"},
            {"$ref": "#/$defs/acontainsExpression"},
            {"$ref": "#/$defs/acontainedByExpression"},
            {"$ref": "#/$defs/aoverlapsExpression"}
         ]
      },

      "aequalsExpression": {
         "type": "object",
         "required": ["aequals"],
         "properties": {
            "aequals": { "$ref": "#/$defs/arrayExpression" }
         }
      },

      "acontainsExpression": {
         "type": "object",
         "required": ["acontains"],
         "properties": {
            "acontains": { "$ref": "#/$defs/arrayExpression" }
         }
      },

      "acontainedByExpression": {
         "type": "object",
         "required": ["acontainedBy"],
         "properties": {
            "acontainedBy": { "$ref": "#/$defs/arrayExpression" }
         }
      },

      "aoverlapsExpression": {
         "type": "object",
         "required": ["aoverlaps"],
         "properties": {
            "aoverlaps": { "$ref": "#/$defs/arrayExpression" }
         }
      },

      "arrayExpression": {
         "type": "array",
         "minItems": 2,
         "maxItems": 2,
         "items": {
            "oneOf": [
               { "$ref": "#/$defs/propertyRef" },
               { "$ref": "#/$defs/functionRef" },
               { "$ref": "#/$defs/arrayLiteral" }
            ]
         }
      },

      "arrayLiteral": {
         "type": "array",
         "items": {
            "oneOf": [
               {"$ref": "#/$defs/scalarLiteral"},
               {"$ref": "#/$defs/spatialLiteral"},
               {"$ref": "#/$defs/typedTemporalLiteral"},
               { "$ref": "#/$defs/propertyRef" },
               { "$ref": "#/$defs/functionRef" },
               {"$ref": "#/$defs/arithmeticExpression"},
               { "$ref": "#/$defs/arrayLiteral" }
            ]
         }
      },

      "$comment": "=======================================================",
      "$comment": "=  ARITHMETIC EXPRESSIONS                             =",
      "$comment": "=======================================================",

      "arithmeticExpression": {
         "oneOf": [
            {"$ref": "#/$defs/addExpression" },
            {"$ref": "#/$defs/subExpression" },
            {"$ref": "#/$defs/mulExpression" },
            {"$ref": "#/$defs/divExpression" }
         ]
      },

      "addExpression": {
         "type": "object",
         "required": ["+"],
         "properties": {
            "+": { "$ref": "#/$defs/arithmeticOperands" }
         }
      },

      "subExpression": {
         "type": "object",
         "required": ["-"],
         "properties": {
            "-": { "$ref": "#/$defs/arithmeticOperands" }
         }
      },

      "mulExpression": {
         "type": "object",
         "required": ["*"],
         "properties": {
            "*": { "$ref": "#/$defs/arithmeticOperands" }
         }
      },

      "divExpression": {
         "type": "object",
         "required": ["*"],
         "properties": {
            "/": { "$ref": "#/$defs/arithmeticOperands" }
         }
      },

      "arithmeticOperands": {
         "type": "array",
         "minItems": 2,
         "maxItems": 2,
         "items": {
            "oneOf": [
               {"$ref": "#/$defs/arithmeticExpression"},
               {"$ref": "#/$defs/propertyRef"},
               {"$ref": "#/$defs/functionRef"},
               {"type": "number" }
            ]
         }
      },

      "$comment": "=======================================================",
      "$comment": "=  PROPERTY REFERENCE                                 =",
      "$comment": "=======================================================",
      "propertyRef": {
         "type": "object",
         "required": ["property"],
         "properties": {
            "propertyName": { "type": "string" }
         }
      },

      "$comment": "=======================================================",
      "$comment": "=  FUNCTIONS                                          =",
      "$comment": "=======================================================",

      "functionRef": {
         "type": "object",
         "required": ["function"],
         "properties": {
            "function": { "$ref": "#/$defs/function" }
         }
      },

      "function": {
         "type": "object",
         "required": [ "name" ],
         "properties": {
            "name": { "type": "string" },
            "arguments": {
               "type": "array",
               "items": {
                  "oneOf": [
                     { "$ref": "#/$defs/scalarLiteral" },
                     { "$ref": "#/$defs/spatialLiteral" },
                     { "$ref": "#/$defs/typedTemporalLiteral" },
                     { "$ref": "#/$defs/propertyRef" },
                     { "$ref": "#/$defs/functionRef" },
                     { "$ref": "#/$defs/arithmeticExpression" },
                     { "$ref": "#/$defs/arrayLiteral" }
                  ]
               }
            }
         }
      },

      "$comment": "=======================================================",
      "$comment": "=  LITERALS                                           =",
      "$comment": "=======================================================",

      "scalarLiteral": {
         "oneOf": [
            { "type": "string" },
            { "type": "number" },
            { "type": "boolean"}
         ]
      },

      "spatialLiteral": {
         "oneOf": [
            { "$ref": "#/$defs/geometryLiteral" },
            { "$ref": "#/$defs/envelopeLiteral" }
         ]
      },

      "geometryLiteral": {
         "oneOf": [
            { "$ref": "#/$defs/point" },
            { "$ref": "#/$defs/linestring" },
            { "$ref": "#/$defs/polygon" },
            { "$ref": "#/$defs/multipoint" },
            { "$ref": "#/$defs/multilinestring" },
            { "$ref": "#/$defs/multipolygon" }
         ]
      },

      "point": {
         "title": "GeoJSON Point",
         "type": "object",
         "required": ["type","coordinates"],
         "properties": {
            "type": {
               "type": "string",
               "enum": ["Point"]
            },
            "coordinates": {
               "type": "array",
               "minItems": 2,
               "items": {
                  "type": "number"
               }
            },
            "bbox": {
               "type": "array",
               "minItems": 4,
               "items": {
                  "type": "number"
               }
            }
         }
      },

      "linestring": {
         "title": "GeoJSON LineString",
         "type": "object",
         "required": ["type","coordinates"],
         "properties": {
            "type": {
               "type": "string",
               "enum": ["LineString"]
            },
            "coordinates": {
               "type": "array",
               "minItems": 2,
               "items": {
                  "type": "array",
                  "minItems": 2,
                  "items": {
                     "type": "number"
                  }
               }
            },
            "bbox": {
               "type": "array",
               "minItems": 4,
               "items": {
                  "type": "number"
               }
            }
         }
      },

      "polygon": {
         "title": "GeoJSON Polygon",
         "type": "object",
         "required": ["type","coordinates"],
         "properties": {
            "type": {
               "type": "string",
               "enum": ["Polygon"]
            },
            "coordinates": {
               "type": "array",
               "items": {
                  "type": "array",
                  "minItems": 4,
                  "items": {
                     "type": "array",
                     "minItems": 2,
                     "items": {
                        "type": "number"
                     }
                  }
               }
            },
            "bbox": {
               "type": "array",
               "minItems": 4,
               "items": {
                  "type": "number"
               }
            }
         }
      },

      "multipoint": {
         "title": "GeoJSON MultiPoint",
         "type": "object",
         "required": ["type","coordinates"],
         "properties": {
            "type": {
               "type": "string",
               "enum": ["MultiPoint"]
            },
            "coordinates": {
               "type": "array",
               "items": {
                  "type": "array",
                  "minItems": 2,
                  "items": {
                     "type": "number"
                  }
               }
            },
            "bbox": {
               "type": "array",
               "minItems": 4,
               "items": {
                  "type": "number"
               }
            }
         }
      },

      "multilinestring": {
         "title": "GeoJSON MultiLineString",
         "type": "object",
         "required": ["type","coordinates"],
         "properties": {
            "type": {
               "type": "string",
               "enum": ["MultiLineString"]
            },
            "coordinates": {
               "type": "array",
               "items": {
                  "type": "array",
                  "minItems": 2,
                  "items": {
                     "type": "array",
                     "minItems": 2,
                     "items": {
                        "type": "number"
                     }
                  }
               }
            },
            "bbox": {
               "type": "array",
               "minItems": 4,
               "items": {
                  "type": "number"
               }
            }
         }
      },

      "multipolygon": {
         "title": "GeoJSON MultiPolygon",
         "type": "object",
         "required": ["type","coordinates"],
         "properties": {
            "type": {
               "type": "string",
               "enum": ["MultiPolygon"]
            },
            "coordinates": {
               "type": "array",
               "items": {
                  "type": "array",
                  "items": {
                     "type": "array",
                     "minItems": 4,
                     "items": {
                        "type": "array",
                        "minItems": 2,
                        "items": {
                           "type": "number"
                        }
                     }
                  }
               }
            },
            "bbox": {
               "type": "array",
               "minItems": 4,
               "items": {
                  "type": "number"
               }
            }
         }
      },

      "envelopeLiteral": {
         "type": "object",
         "required": [ "bbox" ],
         "properties": {
            "bbox": { "$ref": "#/$defs/bbox" }
         }
      },

      "bbox": {
         "type": "array",
         "oneOf": [
            { "minItems": 4, "maxItems": 4},
            { "minItems": 6, "maxItems": 6}
         ],
         "items": {
            "type": "number"
         }
      },

      "temporalLiteral": {
         "oneOf": [
            { "$ref": "#/$defs/timeString" },
            { "$ref": "#/$defs/periodString" }
         ]
      },

      "timeString": {
         "oneOf": [
            { "type": "string", "format": "date" },
            { "type": "string", "format": "date-time" }
         ]
      },

      "periodString": {
         "type": "array",
         "minItems": 2,
         "maxItems": 2,
         "items": {
            "oneOf": [
               { "$ref": "#/$defs/timeString" },
               { "type": "string", "enum": [".."] }
            ]
         }
      },

      "typedTemporalLiteral": {
         "oneOf": [
            { "$ref": "#/$defs/typedTimeString" },
            { "$ref": "#/$defs/typedPeriodString" }
         ]
      },

      "typedTimeString": {
         "type": "object",
         "required": ["datetime"],
         "properties": {
            "datetime": {
               "$ref": "#/$defs/timeString"
            }
         }
      },

      "typedPeriodString": {
         "type": "object",
         "required": ["datetime"],
         "properties": {
            "datetime": {
               "$ref": "#/$defs/periodString"
            }
         }
      }
   }
}