swagger.json

{
   "basePath":"/db",
   "definitions":{
      "Error":{
         "description":"A human readable error mesage.",
         "type":"string"
      },
      "GraphQLRequest":{
         "properties":{
            "operationName":{
               "description":"GraphQL query operation name.",
               "type":"string"
            },
            "query":{
               "description":"GraphQL query.",
               "type":"string"
            },
            "variables":{
               "description":"GraphQL query variable values.",
               "type":"object"
            }
         },
         "type":"object"
      },
      "GroupSelectionState":{
         "properties":{
            "groups":{
               "description":"List of group names which include one or more selected nodes.",
               "items":{
                  "description":"Group name.",
                  "type":"string"
               },
               "type":"array"
            },
            "keys":{
               "description":"Lists of selected node keys which are part of the groups in the 'groups' list.",
               "items":{
                  "description":"List of node keys.",
                  "items":{
                     "description":"Node key.",
                     "type":"string"
                  },
                  "type":"array"
               },
               "type":"array"
            },
            "kinds":{
               "description":"Lists of selected node kinds which are part of the groups in the 'groups' list.",
               "items":{
                  "description":"List of node kinds.",
                  "items":{
                     "description":"Node kind.",
                     "type":"string"
                  },
                  "type":"array"
               },
               "type":"array"
            }
         },
         "type":"object"
      },
      "QueryResult":{
         "properties":{
            "groups":{
               "description":"Group names for each row.",
               "items":{
                  "description":" Groups of the primary kind node.",
                  "items":{
                     "description":"Group name.",
                     "type":"string"
                  },
                  "type":"array"
               },
               "type":"array"
            },
            "header":{
               "description":"Header for the query result.",
               "properties":{
                  "data":{
                     "description":"The data which is displayed in each column of the search result.",
                     "items":{
                        "description":"Data source for the column (e.g. 1:n:name - Name of starting nodes, 3:e:key - Key of edge traversed in the second traversal).",
                        "type":"string"
                     },
                     "type":"array"
                  },
                  "format":{
                     "description":"All column format definitions of the search result.",
                     "items":{
                        "description":"Column format as specified in the show format (e.g. text).",
                        "type":"string"
                     },
                     "type":"array"
                  },
                  "labels":{
                     "description":"All column labels of the search result.",
                     "items":{
                        "description":"Column label.",
                        "type":"string"
                     },
                     "type":"array"
                  }
               },
               "type":"object"
            },
            "rows":{
               "description":"Rows of the query result.",
               "items":{
                  "description":"Columns of a row of the query result.",
                  "items":{
                     "description":"A single cell of the query result (string, integer or null).",
                     "type":"object"
                  },
                  "type":"array"
               },
               "type":"array"
            },
            "selections":{
               "description":"List of row selections.",
               "items":{
                  "description":"Row selection.",
                  "type":"boolean"
               },
               "type":"array"
            },
            "sources":{
               "description":"Data sources of the query result.",
               "items":{
                  "description":"Columns of a row of the query result.",
                  "items":{
                     "description":"Data source of a single cell of the query result.",
                     "type":"string"
                  },
                  "type":"array"
               },
               "type":"array"
            },
            "total_selections":{
               "description":"Number of total selections.",
               "format":"integer",
               "type":"number"
            }
         },
         "type":"object"
      },
      "SelectionState":{
         "properties":{
            "keys":{
               "description":"Lists of selected node keys.",
               "items":{
                  "description":"Node key.",
                  "type":"string"
               },
               "type":"array"
            },
            "kinds":{
               "description":"Kinds of all selected nodes.",
               "items":{
                  "description":"Node kind.",
                  "type":"string"
               },
               "type":"array"
            }
         },
         "type":"object"
      }
   },
   "host":"127.0.0.1:9090",
   "info":{
      "description":"Query and modify the EliasDB datastore.",
      "title":"EliasDB API",
      "version":"1.0.0"
   },
   "paths":{
      "/about":{
         "get":{
            "description":"Returns available API versions, product name and product version.",
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"About info object",
                  "schema":{
                     "properties":{
                        "api_versions":{
                           "description":"List of available API versions.",
                           "items":{
                              "description":"Available API version.",
                              "type":"string"
                           },
                           "type":"array"
                        },
                        "product":{
                           "description":"Product name of the REST API provider.",
                           "type":"string"
                        },
                        "version":{
                           "description":"Version of the REST API provider.",
                           "type":"string"
                        }
                     },
                     "type":"object"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Return information about the REST API provider."
         }
      },
      "/v1/blob/{partition}":{
         "post":{
            "consumes":[
               "application/octet-stream"
            ],
            "description":"The blob endpoint can be used to store binary data. Its location will be automatically allocated.",
            "parameters":[
               {
                  "description":"The data to store.",
                  "in":"body",
                  "name":"data",
                  "required":true,
                  "schema":{
                     "description":"A blob of binary data."
                  }
               },
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"The operation was successful.",
                  "schema":{
                     "properties":{
                        "id":{
                           "description":"The data ID which can be used to lookup the data.",
                           "type":"number"
                        }
                     },
                     "type":"object"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Create a binary blob of data."
         }
      },
      "/v1/blob/{partition}/{id}":{
         "delete":{
            "description":"The blob endpoint can be used to remove binary data from a specific location.",
            "parameters":[
               {
                  "description":"ID of the binary blob.",
                  "in":"path",
                  "name":"id",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain"
            ],
            "responses":{
               "200":{
                  "description":"The operation was successful."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Remove a binary blob of data."
         },
         "get":{
            "description":"The blob endpoint can be used to retrieve binary data from a specific location.",
            "parameters":[
               {
                  "description":"ID of the binary blob.",
                  "in":"path",
                  "name":"id",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/octet-stream"
            ],
            "responses":{
               "200":{
                  "description":"The requested binary blob."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Retrieve a binary blob of data."
         },
         "put":{
            "description":"The blob endpoint can be used to update binary data at a specific location.",
            "parameters":[
               {
                  "description":"ID of the binary blob.",
                  "in":"path",
                  "name":"id",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain"
            ],
            "responses":{
               "200":{
                  "description":"The operation was successful."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Update a binary blob of data."
         }
      },
      "/v1/cluster":{
         "get":{
            "description":"The cluster endpoint returns the cluster state info which contains cluster members and their state.",
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"A key-value map."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Return cluster specific information."
         }
      },
      "/v1/cluster/log":{
         "delete":{
            "description":"A delete call to the log endpoint resets the cluster related log and clears the ring buffer in memory.",
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"Cluster related log was reset."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Reset the cluster log."
         },
         "get":{
            "description":"The cluster log endpoint returns the latest cluster related log messages from a memory ring buffer.",
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"A list of log messages."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Return latest cluster related log messages."
         }
      },
      "/v1/cluster/memberinfos":{
         "get":{
            "description":"The memberinfos returns the static member info of every known cluster member. If a member is not reachable its info contains a single key-value pair with the key error and an error message as value.",
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"A map of memberinfos (keys are member names)."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Return static member info of every known cluster member."
         }
      },
      "/v1/cluster/{command}":{
         "put":{
            "consumes":[
               "application/json"
            ],
            "description":"The cluster can be controlled via this command endpoint on any member.",
            "parameters":[
               {
                  "description":"Valid commands are: ping, join and eject.",
                  "in":"path",
                  "name":"command",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Arguments for a command",
                  "in":"body",
                  "name":"args",
                  "required":true,
                  "schema":{
                     "properties":{
                        "name":{
                           "description":"Name of a cluster member (ping/join=member to contact, eject=member to eject).",
                           "type":"string"
                        },
                        "netaddr":{
                           "description":"Network address of a member e.g. localhost:9030 (ping/join=member address to contact)",
                           "type":"string"
                        }
                     },
                     "type":"object"
                  }
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"Only the ping command returns its result. All other positive responses are empty."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Commands can be given to the cluster by using PUT requests."
         }
      },
      "/v1/eql":{
         "post":{
            "consumes":[
               "application/json"
            ],
            "description":"The eql endpoint should be used to parse a given EQL query into an Abstract Syntax Tree or pretty print a given Abstract Syntax Tree into an EQL query.",
            "parameters":[
               {
                  "description":"Query or AST which should be converted.",
                  "in":"body",
                  "name":"data",
                  "required":true,
                  "schema":{
                     "properties":{
                        "ast":{
                           "description":"AST which should be pretty printed.",
                           "type":"object"
                        },
                        "query":{
                           "description":"Query which should be parsed.",
                           "type":"string"
                        }
                     },
                     "type":"object"
                  }
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"The operation was successful.",
                  "schema":{
                     "properties":{
                        "ast":{
                           "description":"The resulting AST if a query was parsed.",
                           "type":"object"
                        },
                        "query":{
                           "description":"The pretty printed query if an AST was given.",
                           "type":"string"
                        }
                     },
                     "type":"object"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"EQL parser and pretty printer endpoint."
         }
      },
      "/v1/find":{
         "get":{
            "description":"The find endpoint should be used to run simple index searches for either a value or a phrase.",
            "parameters":[
               {
                  "description":"A word or phrase to search for.",
                  "in":"query",
                  "name":"text",
                  "required":false,
                  "type":"string"
               },
               {
                  "description":"A node value to search for.",
                  "in":"query",
                  "name":"value",
                  "required":false,
                  "type":"string"
               },
               {
                  "description":"Flag if a complete node lookup should be done (otherwise only key and kind are returned).",
                  "in":"query",
                  "name":"lookup",
                  "required":false,
                  "type":"boolean"
               },
               {
                  "description":"Limit the search to a partition (without the option all partitions are searched).",
                  "in":"query",
                  "name":"part",
                  "required":false,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"An object of search results.",
                  "schema":{
                     "description":"Object of results per partition.",
                     "properties":{
                        "partition":{
                           "description":"Object of results per kind.",
                           "properties":{
                              "kind":{
                                 "description":"List of found nodes.",
                                 "items":{
                                    "description":"Found node.",
                                    "type":"object"
                                 },
                                 "type":"array"
                              }
                           },
                           "type":"object"
                        }
                     },
                     "type":"object"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Run index searches on the EliasDB datastore."
         }
      },
      "/v1/graph/{partition}":{
         "delete":{
            "consumes":[
               "application/json"
            ],
            "description":"A whole graph can be send. DELETE will delete data in the datastore - only key and kind are required.",
            "parameters":[
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Nodes and Edges which should be stored",
                  "in":"body",
                  "name":"entities",
                  "required":true,
                  "schema":{
                     "properties":{
                        "edges":{
                           "description":"List of edges to be inserted / updated.",
                           "items":{
                              "description":"Edge to be inserted / updated.",
                              "type":"object"
                           },
                           "type":"array"
                        },
                        "nodes":{
                           "description":"List of nodes to be inserted / updated.",
                           "items":{
                              "description":"Node to be inserted / updated.",
                              "type":"object"
                           },
                           "type":"array"
                        }
                     },
                     "type":"object"
                  }
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"No data is returned when data is created."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Data can be send by using DELETE requests."
         },
         "post":{
            "consumes":[
               "application/json"
            ],
            "description":"A whole graph can be send. POST will store data in the datastore and always overwrite any existing data.",
            "parameters":[
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Nodes and Edges which should be stored",
                  "in":"body",
                  "name":"entities",
                  "required":true,
                  "schema":{
                     "properties":{
                        "edges":{
                           "description":"List of edges to be inserted / updated.",
                           "items":{
                              "description":"Edge to be inserted / updated.",
                              "type":"object"
                           },
                           "type":"array"
                        },
                        "nodes":{
                           "description":"List of nodes to be inserted / updated.",
                           "items":{
                              "description":"Node to be inserted / updated.",
                              "type":"object"
                           },
                           "type":"array"
                        }
                     },
                     "type":"object"
                  }
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"No data is returned when data is created."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Data can be send by using POST requests."
         },
         "put":{
            "consumes":[
               "application/json"
            ],
            "description":"A whole graph can be send. PUT will store data in the datastore and update existing data.",
            "parameters":[
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Nodes and Edges which should be stored",
                  "in":"body",
                  "name":"entities",
                  "required":true,
                  "schema":{
                     "properties":{
                        "edges":{
                           "description":"List of edges to be inserted / updated.",
                           "items":{
                              "description":"Edge to be inserted / updated.",
                              "type":"object"
                           },
                           "type":"array"
                        },
                        "nodes":{
                           "description":"List of nodes to be inserted / updated.",
                           "items":{
                              "description":"Node to be inserted / updated.",
                              "type":"object"
                           },
                           "type":"array"
                        }
                     },
                     "type":"object"
                  }
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"No data is returned when data is created."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Data can be send by using PUT requests."
         }
      },
      "/v1/graph/{partition}/{entity_type}":{
         "delete":{
            "consumes":[
               "application/json"
            ],
            "description":"A list of nodes / edges can be send. DELETE will delete data in the datastore - only key and kind are required.",
            "parameters":[
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Datastore entity type which should selected. Either n for nodes or e for edges.",
                  "in":"path",
                  "name":"entity_type",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Nodes or Edges which should be stored",
                  "in":"body",
                  "name":"entities",
                  "required":true,
                  "schema":{
                     "items":{
                        "description":"Node or edge to be inserted / updated.",
                        "type":"object"
                     },
                     "type":"array"
                  }
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"No data is returned when data is created."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Data can be send by using DELETE requests."
         },
         "post":{
            "consumes":[
               "application/json"
            ],
            "description":"A list of nodes / edges can be send. POST will store data in the datastore and always overwrite any existing data.",
            "parameters":[
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Datastore entity type which should selected. Either n for nodes or e for edges.",
                  "in":"path",
                  "name":"entity_type",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Nodes or Edges which should be stored",
                  "in":"body",
                  "name":"entities",
                  "required":true,
                  "schema":{
                     "items":{
                        "description":"Node or edge to be inserted / updated.",
                        "type":"object"
                     },
                     "type":"array"
                  }
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"No data is returned when data is created."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Data can be send by using POST requests."
         },
         "put":{
            "consumes":[
               "application/json"
            ],
            "description":"A list of nodes / edges can be send. PUT will store data in the datastore and update existing data.",
            "parameters":[
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Datastore entity type which should selected. Either n for nodes or e for edges.",
                  "in":"path",
                  "name":"entity_type",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Nodes or Edges which should be stored",
                  "in":"body",
                  "name":"entities",
                  "required":true,
                  "schema":{
                     "items":{
                        "description":"Node or edge to be inserted / updated.",
                        "type":"object"
                     },
                     "type":"array"
                  }
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"No data is returned when data is created."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Data can be send by using PUT requests."
         }
      },
      "/v1/graph/{partition}/{entity_type}/{kind}":{
         "get":{
            "description":"GET requests can be used to query a series of nodes. The X-Total-Count header contains the total number of nodes which were found.",
            "parameters":[
               {
                  "description":"Node or edge kind to be queried.",
                  "in":"path",
                  "name":"kind",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Datastore entity type which should selected. Either n for nodes or e for edges.",
                  "in":"path",
                  "name":"entity_type",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"How many list items to return.",
                  "format":"integer",
                  "in":"query",
                  "name":"limit",
                  "required":false,
                  "type":"number"
               },
               {
                  "description":"Offset in the dataset.",
                  "format":"integer",
                  "in":"query",
                  "name":"offset",
                  "required":false,
                  "type":"number"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"The return data is a list of objects",
                  "schema":{
                     "items":{
                        "type":"object"
                     },
                     "type":"array"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"The graph endpoint is the main entry point to request data."
         }
      },
      "/v1/graph/{partition}/{entity_type}/{kind}/{key}":{
         "get":{
            "description":"GET requests can be used to query a single node.",
            "parameters":[
               {
                  "description":"Node or edge kind to be queried.",
                  "in":"path",
                  "name":"kind",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Datastore entity type which should selected. Either n for nodes or e for edges.",
                  "in":"path",
                  "name":"entity_type",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Node or edge key to be queried.",
                  "in":"path",
                  "name":"key",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"How many list items to return.",
                  "format":"integer",
                  "in":"query",
                  "name":"limit",
                  "required":false,
                  "type":"number"
               },
               {
                  "description":"Offset in the dataset.",
                  "format":"integer",
                  "in":"query",
                  "name":"offset",
                  "required":false,
                  "type":"number"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"The return data is a single object",
                  "schema":{
                     "type":"object"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"The graph endpoint is the main entry point to request data."
         }
      },
      "/v1/graph/{partition}/{entity_type}/{kind}/{key}/{traversal_spec}":{
         "get":{
            "description":"GET requests can be used to query a single node and then traverse to its neighbours.",
            "parameters":[
               {
                  "description":"Node or edge kind to be queried.",
                  "in":"path",
                  "name":"kind",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Partition to select.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Datastore entity type which should selected. Either n for nodes or e for edges.",
                  "in":"path",
                  "name":"entity_type",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Node or edge key to be queried.",
                  "in":"path",
                  "name":"key",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Traversal to be followed from a single node.",
                  "in":"path",
                  "name":"traversal_spec",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"The return data are two lists containing traversed nodes and edges. The traversal endpoint does NOT support limit and offset parameters. Also the X-Total-Count header is not set.",
                  "schema":{
                     "items":{
                        "items":{
                           "type":"object"
                        },
                        "type":"array"
                     },
                     "type":"array"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"The graph endpoint is the main entry point to request data."
         }
      },
      "/v1/graphql-query/{partition}":{
         "get":{
            "consumes":[
               "application/json"
            ],
            "description":"The GraphQL interface can be used to query data.",
            "parameters":[
               {
                  "description":"Partition to query.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"GraphQL query operation name.",
                  "in":"query",
                  "name":"operationName",
                  "required":false,
                  "type":"string"
               },
               {
                  "description":"GraphQL query.",
                  "in":"query",
                  "name":"query",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"GraphQL query variable values.",
                  "in":"query",
                  "name":"variables",
                  "required":false,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"The operation was successful."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"GraphQL interface which only executes non-modifying queries."
         }
      },
      "/v1/graphql/{partition}":{
         "post":{
            "consumes":[
               "application/json"
            ],
            "description":"The GraphQL interface can be used to query and modify data.",
            "parameters":[
               {
                  "description":"Partition to query.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"GraphQL request",
                  "in":"body",
                  "name":"graphql_request",
                  "required":true,
                  "schema":{
                     "$ref":"#/definitions/GraphQLRequest"
                  }
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"The operation was successful."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"GraphQL interface."
         }
      },
      "/v1/index/{partition}/{entity_type}/{kind}":{
         "get":{
            "description":"The index endpoint should be used to run index searches for either a word, phrase or a whole value. All queries must specify a kind and an node/edge attribute.",
            "parameters":[
               {
                  "description":"Partition to query.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Datastore entity type which should selected. Either n for nodes or e for edges.",
                  "in":"path",
                  "name":"entity_type",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Node or edge kind to be queried.",
                  "in":"path",
                  "name":"kind",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Attribute which should contain the word, phrase or value.",
                  "in":"query",
                  "name":"attr",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Word to search for in word queries.",
                  "in":"query",
                  "name":"word",
                  "required":false,
                  "type":"string"
               },
               {
                  "description":"Phrase to search for in phrase queries.",
                  "in":"query",
                  "name":"phrase",
                  "required":false,
                  "type":"string"
               },
               {
                  "description":"Value (node/edge attribute value) to search for in value queries.",
                  "in":"query",
                  "name":"value",
                  "required":false,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"A list of keys or when doing a word search a map with node/edge key to word positions."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Run index searches on the EliasDB datastore."
         }
      },
      "/v1/info":{
         "get":{
            "description":"The info endpoint returns general database information such as known node kinds, known attributes, etc.",
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"A key-value map."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Return general datastore information."
         }
      },
      "/v1/info/kind/{kind}":{
         "get":{
            "description":"The info kind endpoint returns information on a given node kind such as known attributes and edges.",
            "parameters":[
               {
                  "description":"Node or edge kind to be queried.",
                  "in":"path",
                  "name":"kind",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"A key-value map."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Return information on a given node or edge kind."
         }
      },
      "/v1/query/{partition}":{
         "get":{
            "description":"The query endpoint should be used to run EQL search queries against partitions. The return value is always a list (even if there is only a single entry). A query result gets an ID and is stored in a cache. The ID is returned in the X-Cache-Id header. Subsequent requests for the same result can use the ID instead of a query.",
            "parameters":[
               {
                  "description":"Partition to query.",
                  "in":"path",
                  "name":"partition",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"URL encoded query to execute.",
                  "in":"query",
                  "name":"q",
                  "required":false,
                  "type":"string"
               },
               {
                  "description":"Result ID to retrieve from the result cache.",
                  "format":"integer",
                  "in":"query",
                  "name":"rid",
                  "required":false,
                  "type":"number"
               },
               {
                  "description":"How many list items to return.",
                  "format":"integer",
                  "in":"query",
                  "name":"limit",
                  "required":false,
                  "type":"number"
               },
               {
                  "description":"Offset in the dataset.",
                  "format":"integer",
                  "in":"query",
                  "name":"offset",
                  "required":false,
                  "type":"number"
               },
               {
                  "description":"Include group information in the result if set to any value.",
                  "format":"integer",
                  "in":"query",
                  "name":"groups",
                  "required":false,
                  "type":"number"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"A query result",
                  "schema":{
                     "$ref":"#/definitions/QueryResult"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Run EQL queries to query the EliasDB datastore."
         }
      },
      "/v1/queryresult/{rid}/csv":{
         "get":{
            "description":"The csv endpoint is used to generate a CSV string from the search result.",
            "parameters":[
               {
                  "description":"Result ID of a query result.",
                  "in":"path",
                  "name":"rid",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain"
            ],
            "responses":{
               "200":{
                  "description":"A CSV string."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Return the search result in CSV format."
         }
      },
      "/v1/queryresult/{rid}/groupselected":{
         "get":{
            "description":"Returns the current selections state which contains all selected nodes which are in groups.",
            "parameters":[
               {
                  "description":"Result ID of a query result.",
                  "in":"path",
                  "name":"rid",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"Current group selection state.",
                  "schema":{
                     "$ref":"#/definitions/GroupSelectionState"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Get the current group selection state."
         },
         "post":{
            "description":"Sets the groups in the given selection state.",
            "parameters":[
               {
                  "description":"Result ID of a query result.",
                  "in":"path",
                  "name":"rid",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Group seletion state of a query result",
                  "in":"body",
                  "name":"selection_state",
                  "required":true,
                  "schema":{
                     "$ref":"#/definitions/GroupSelectionState"
                  }
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"Current group selection state after the operation.",
                  "schema":{
                     "$ref":"#/definitions/GroupSelectionState"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Set a new group selection state."
         }
      },
      "/v1/queryresult/{rid}/groupselected/{group_name}":{
         "delete":{
            "description":"The groupselected endpoint is used to remove all selected nodes (primary node of each row) from the given (existing) group.",
            "parameters":[
               {
                  "description":"Result ID of a query result.",
                  "in":"path",
                  "name":"rid",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Name of an existing group.",
                  "in":"path",
                  "name":"group_name",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"Current group selection state after the operation.",
                  "schema":{
                     "$ref":"#/definitions/GroupSelectionState"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Remove all selected nodes (primary node of each row) from the given group."
         },
         "put":{
            "description":"The groupselected endpoint is used to add all selected nodes (primary node of each row) to the given (existing) group.",
            "parameters":[
               {
                  "description":"Result ID of a query result.",
                  "in":"path",
                  "name":"rid",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Name of an existing group.",
                  "in":"path",
                  "name":"group_name",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"Current group selection state after the operation.",
                  "schema":{
                     "$ref":"#/definitions/GroupSelectionState"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Add all selected nodes (primary node of each row) to the given group."
         }
      },
      "/v1/queryresult/{rid}/quickfilter/{column}":{
         "get":{
            "description":"The quickfilter endpoint is used to determine the 10 most frequent used values in a particular result column.",
            "parameters":[
               {
                  "description":"Result ID of a query result.",
                  "in":"path",
                  "name":"rid",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Column of the query result.",
                  "in":"path",
                  "name":"column",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Limit the maximum number of result items.",
                  "in":"query",
                  "name":"limit",
                  "required":false,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"An object containing values and frequencies."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Return quickfilter information on a given result column."
         }
      },
      "/v1/queryresult/{rid}/select":{
         "get":{
            "description":"The select endpoint is used to query all selected nodes of a given query result.",
            "parameters":[
               {
                  "description":"Result ID of a query result.",
                  "in":"path",
                  "name":"rid",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"Current total selections.",
                  "schema":{
                     "$ref":"#/definitions/SelectionState"
                  }
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Return the (primary) nodes which are currently selected."
         }
      },
      "/v1/queryresult/{rid}/select/{row}":{
         "put":{
            "description":"The select endpoint is used to select one or more rows of a given query result.",
            "parameters":[
               {
                  "description":"Result ID of a query result.",
                  "in":"path",
                  "name":"rid",
                  "required":true,
                  "type":"string"
               },
               {
                  "description":"Row number of the query result or 'all', 'none' or 'invert'.",
                  "in":"path",
                  "name":"row",
                  "required":true,
                  "type":"string"
               }
            ],
            "produces":[
               "text/plain",
               "application/json"
            ],
            "responses":{
               "200":{
                  "description":"Current total selections."
               },
               "default":{
                  "description":"Error response",
                  "schema":{
                     "$ref":"#/definitions/Error"
                  }
               }
            },
            "summary":"Selects one or more rows of a given query result."
         }
      }
   },
   "produces":[
      "application/json"
   ],
   "schemes":[
      "https"
   ],
   "swagger":"2.0"
}