diff --git a/types/arangodb/arangodb-tests.ts b/types/arangodb/arangodb-tests.ts
index b498caf6af..da5e1e40c2 100644
--- a/types/arangodb/arangodb-tests.ts
+++ b/types/arangodb/arangodb-tests.ts
@@ -1,4 +1,4 @@
-import { db, aql } from "@arangodb";
+import { db, aql, query } from "@arangodb";
 import { md5 } from "@arangodb/crypto";
 import { createRouter } from "@arangodb/foxx";
 import sessionsMiddleware = require("@arangodb/foxx/sessions");
@@ -21,16 +21,37 @@ const admin = users.firstExample({ username: "admin" })!;
 users.update(admin, { password: md5("hunter2") });
 console.logLines("user", admin._key, admin.username);
 
-const query = aql`
+db._query(aql`
     FOR u IN ${users}
     RETURN u
-`;
+`);
 
-db._createDocumentCollection("bananas").ensureIndex({
+interface Banana {
+    color: string;
+    shape: {
+        type: string;
+        coords: string[];
+    };
+}
+
+const bananas = db._createDocumentCollection("bananas", {
+    waitForSync: false,
+    keyOptions: {
+        type: "autoincrement",
+        increment: 11,
+        offset: 23
+    }
+}) as ArangoDB.Collection<Banana>;
+bananas.ensureIndex({
     type: "hash",
     unique: true,
-    fields: ["color", "shape"]
+    fields: ["color", "shape.type"]
 });
+bananas.updateByExample(
+    bananas.any(),
+    { shape: { type: "round" } },
+    { mergeObjects: true }
+);
 
 const router = createRouter();
 module.context.use(router);
@@ -61,3 +82,13 @@ router.use(
         transport: cookieTransport({ secret: "banana", algorithm: "sha256" })
     })
 );
+
+console.log(
+    query`
+        FOR u IN users
+        ${aql.literal(
+            Math.random() < 0.5 ? "FILTER u.admin" : "FILTER !u.admin"
+        )}
+        RETURN u
+    `.toArray()
+);
diff --git a/types/arangodb/index.d.ts b/types/arangodb/index.d.ts
index 34cf3ef99e..deed6a97c5 100644
--- a/types/arangodb/index.d.ts
+++ b/types/arangodb/index.d.ts
@@ -91,6 +91,7 @@ declare namespace ArangoDB {
     type EngineType = "mmfiles" | "rocksdb";
     type IndexType = "hash" | "skiplist" | "fulltext" | "geo1" | "geo2";
     type ViewType = "arangosearch";
+    type KeyGeneratorType = "traditional" | "autoincrement";
     type ErrorName =
         | "ERROR_NO_ERROR"
         | "ERROR_FAILED"
@@ -463,12 +464,29 @@ declare namespace ArangoDB {
         replicationFactor?: number;
     }
 
+    interface CreateCollectionOptions {
+        waitForSync?: boolean;
+        journalSize?: number;
+        isVolatile?: boolean;
+        isSystem?: boolean;
+        keyOptions?: {
+            type?: KeyGeneratorType;
+            allowUserKeys?: boolean;
+            increment?: number;
+            offset?: number;
+        };
+        numberOfShards?: number;
+        shardKeys?: string[];
+        replicationFactor?: number;
+    }
+
     interface CollectionProperties {
         waitForSync: boolean;
         journalSize: number;
+        isSystem: boolean;
         isVolatile: boolean;
         keyOptions?: {
-            type: string;
+            type: KeyGeneratorType;
             allowUserKeys: boolean;
             increment?: number;
             offset?: number;
@@ -488,7 +506,7 @@ declare namespace ArangoDB {
 
     interface IndexDescription<T> {
         type: IndexType;
-        fields: ReadonlyArray<keyof T>;
+        fields: ReadonlyArray<keyof T | string>;
         sparse?: boolean;
         unique?: boolean;
         deduplicate?: boolean;
@@ -497,7 +515,7 @@ declare namespace ArangoDB {
     interface Index<T extends object = any> {
         id: string;
         type: IndexType;
-        fields: Array<keyof T>;
+        fields: Array<keyof T | string>;
         sparse: boolean;
         unique: boolean;
         deduplicate: boolean;
@@ -520,6 +538,8 @@ declare namespace ArangoDB {
 
     type DocumentLike = ObjectWithId | ObjectWithKey;
 
+    type Patch<T> = { [K in keyof T]?: T[K] | Patch<T[K]> };
+
     interface DocumentMetadata {
         _key: string;
         _id: string;
@@ -572,6 +592,7 @@ declare namespace ArangoDB {
         keepNull?: boolean;
         waitForSync?: boolean;
         limit?: number;
+        mergeObjects?: boolean;
     }
 
     interface RemoveOptions {
@@ -706,24 +727,24 @@ declare namespace ArangoDB {
         ): InsertResult<T>;
         update(
             selector: string | DocumentLike,
-            data: Partial<Document<T>>,
+            data: Patch<Document<T>>,
             options?: UpdateOptions
         ): UpdateResult<T>;
         update(
             selectors: ReadonlyArray<string | DocumentLike>,
-            data: ReadonlyArray<Partial<Document<T>>>,
+            data: ReadonlyArray<Patch<Document<T>>>,
             options?: UpdateOptions
         ): Array<UpdateResult<T>>;
         updateByExample(
             example: Partial<Document<T>>,
-            newValue: Partial<Document<T>>,
+            newValue: Patch<Document<T>>,
             keepNull?: boolean,
             waitForSync?: boolean,
             limit?: number
         ): number;
         updateByExample(
             example: Partial<Document<T>>,
-            newValue: Partial<Document<T>>,
+            newValue: Patch<Document<T>>,
             options?: UpdateByExampleOptions
         ): number;
     }
@@ -745,6 +766,10 @@ declare namespace ArangoDB {
         options?: QueryOptions;
     }
 
+    interface AqlLiteral {
+        toAQL: () => string;
+    }
+
     interface Cursor<T = any> {
         toArray(): T[];
         hasNext(): boolean;
@@ -862,14 +887,14 @@ declare namespace ArangoDB {
         // Collection
         _collection(name: string): Collection;
         _collections(): Collection[];
-        _create(name: string, properties?: CollectionProperties): Collection;
+        _create(name: string, properties?: CreateCollectionOptions): Collection;
         _createDocumentCollection(
             name: string,
-            properties?: CollectionProperties
+            properties?: CreateCollectionOptions
         ): Collection;
         _createEdgeCollection(
             name: string,
-            properties?: CollectionProperties
+            properties?: CreateCollectionOptions
         ): Collection;
         _drop(name: string): void;
         _truncate(name: string): void;
@@ -930,8 +955,26 @@ declare namespace Foxx {
         set?: (res: Response, sid: string) => void;
         clear?: (res: Response) => void;
     }
+    interface CollectionSessionStorage extends SessionStorage {
+        new: () => Session;
+        save: (session: Session) => Session;
+        clear: (session: Session) => boolean;
+        prune: () => string[];
+    }
+    interface SessionsMiddleware extends DelegateMiddleware {
+        storage: SessionStorage;
+        transport: SessionTransport[];
+    }
 
-    type Middleware = (req: Request, res: Response, next: NextFunction) => void;
+    type SimpleMiddleware = (
+        req: Request,
+        res: Response,
+        next: NextFunction
+    ) => void;
+    interface DelegateMiddleware {
+        register: (endpoint: Endpoint) => SimpleMiddleware;
+    }
+    type Middleware = SimpleMiddleware | DelegateMiddleware;
     type Handler = ((req: Request, res: Response) => void);
     type NextFunction = () => void;
 
@@ -1214,97 +1257,97 @@ declare namespace Foxx {
 
     function route(handler: Handler, name?: string): Endpoint;
     function route(
-        pathOrMiddleware: string | Middleware,
+        pathOrMiddleware: string | SimpleMiddleware,
         handler: Handler,
         name?: string
     ): Endpoint;
     function route(
-        pathOrMiddleware: string | Middleware,
-        middleware: Middleware,
+        pathOrMiddleware: string | SimpleMiddleware,
+        middleware: SimpleMiddleware,
         handler: Handler,
         name?: string
     ): Endpoint;
     function route(
-        pathOrMiddleware: string | Middleware,
-        middleware1: Middleware,
-        middleware2: Middleware,
+        pathOrMiddleware: string | SimpleMiddleware,
+        middleware1: SimpleMiddleware,
+        middleware2: SimpleMiddleware,
         handler: Handler,
         name?: string
     ): Endpoint;
     function route(
-        pathOrMiddleware: string | Middleware,
-        middleware1: Middleware,
-        middleware2: Middleware,
-        middleware3: Middleware,
+        pathOrMiddleware: string | SimpleMiddleware,
+        middleware1: SimpleMiddleware,
+        middleware2: SimpleMiddleware,
+        middleware3: SimpleMiddleware,
         handler: Handler,
         name?: string
     ): Endpoint;
     function route(
-        pathOrMiddleware: string | Middleware,
-        middleware1: Middleware,
-        middleware2: Middleware,
-        middleware3: Middleware,
-        middleware4: Middleware,
+        pathOrMiddleware: string | SimpleMiddleware,
+        middleware1: SimpleMiddleware,
+        middleware2: SimpleMiddleware,
+        middleware3: SimpleMiddleware,
+        middleware4: SimpleMiddleware,
         handler: Handler,
         name?: string
     ): Endpoint;
     function route(
-        pathOrMiddleware: string | Middleware,
-        middleware1: Middleware,
-        middleware2: Middleware,
-        middleware3: Middleware,
-        middleware4: Middleware,
-        middleware5: Middleware,
+        pathOrMiddleware: string | SimpleMiddleware,
+        middleware1: SimpleMiddleware,
+        middleware2: SimpleMiddleware,
+        middleware3: SimpleMiddleware,
+        middleware4: SimpleMiddleware,
+        middleware5: SimpleMiddleware,
         handler: Handler,
         name?: string
     ): Endpoint;
     function route(
-        pathOrMiddleware: string | Middleware,
-        middleware1: Middleware,
-        middleware2: Middleware,
-        middleware3: Middleware,
-        middleware4: Middleware,
-        middleware5: Middleware,
-        middleware6: Middleware,
+        pathOrMiddleware: string | SimpleMiddleware,
+        middleware1: SimpleMiddleware,
+        middleware2: SimpleMiddleware,
+        middleware3: SimpleMiddleware,
+        middleware4: SimpleMiddleware,
+        middleware5: SimpleMiddleware,
+        middleware6: SimpleMiddleware,
         handler: Handler,
         name?: string
     ): Endpoint;
     function route(
-        pathOrMiddleware: string | Middleware,
-        middleware1: Middleware,
-        middleware2: Middleware,
-        middleware3: Middleware,
-        middleware4: Middleware,
-        middleware5: Middleware,
-        middleware6: Middleware,
-        middleware7: Middleware,
+        pathOrMiddleware: string | SimpleMiddleware,
+        middleware1: SimpleMiddleware,
+        middleware2: SimpleMiddleware,
+        middleware3: SimpleMiddleware,
+        middleware4: SimpleMiddleware,
+        middleware5: SimpleMiddleware,
+        middleware6: SimpleMiddleware,
+        middleware7: SimpleMiddleware,
         handler: Handler,
         name?: string
     ): Endpoint;
     function route(
-        pathOrMiddleware: string | Middleware,
-        middleware1: Middleware,
-        middleware2: Middleware,
-        middleware3: Middleware,
-        middleware4: Middleware,
-        middleware5: Middleware,
-        middleware6: Middleware,
-        middleware7: Middleware,
-        middleware8: Middleware,
+        pathOrMiddleware: string | SimpleMiddleware,
+        middleware1: SimpleMiddleware,
+        middleware2: SimpleMiddleware,
+        middleware3: SimpleMiddleware,
+        middleware4: SimpleMiddleware,
+        middleware5: SimpleMiddleware,
+        middleware6: SimpleMiddleware,
+        middleware7: SimpleMiddleware,
+        middleware8: SimpleMiddleware,
         handler: Handler,
         name?: string
     ): Endpoint;
     function route(
-        pathOrMiddleware: string | Middleware,
-        middleware1: Middleware,
-        middleware2: Middleware,
-        middleware3: Middleware,
-        middleware4: Middleware,
-        middleware5: Middleware,
-        middleware6: Middleware,
-        middleware7: Middleware,
-        middleware8: Middleware,
-        middleware9: Middleware,
+        pathOrMiddleware: string | SimpleMiddleware,
+        middleware1: SimpleMiddleware,
+        middleware2: SimpleMiddleware,
+        middleware3: SimpleMiddleware,
+        middleware4: SimpleMiddleware,
+        middleware5: SimpleMiddleware,
+        middleware6: SimpleMiddleware,
+        middleware7: SimpleMiddleware,
+        middleware8: SimpleMiddleware,
+        middleware9: SimpleMiddleware,
         handler: Handler,
         name?: string
     ): Endpoint;
@@ -1327,6 +1370,13 @@ declare namespace Foxx {
 
 declare module "@arangodb" {
     function aql(strings: TemplateStringsArray, ...args: any[]): ArangoDB.Query;
+    namespace aql {
+        function literal(value: any): ArangoDB.AqlLiteral;
+    }
+    function query(
+        strings: TemplateStringsArray,
+        ...args: any[]
+    ): ArangoDB.Cursor;
     function time(): number;
     const db: ArangoDB.Database & {
         [key: string]: ArangoDB.Collection | undefined;
@@ -1362,10 +1412,6 @@ declare module "@arangodb/foxx/graphql" {
 }
 
 declare module "@arangodb/foxx/sessions" {
-    interface SessionsMiddleware extends Foxx.Middleware {
-        storage: Foxx.SessionStorage;
-        transport: Foxx.SessionTransport[];
-    }
     interface SessionsOptions {
         storage: Foxx.SessionStorage | string | ArangoDB.Collection;
         transport:
@@ -1375,7 +1421,9 @@ declare module "@arangodb/foxx/sessions" {
             | "header";
         autoCreate?: boolean;
     }
-    function sessionsMiddleware(options: SessionsOptions): Foxx.Middleware;
+    function sessionsMiddleware(
+        options: SessionsOptions
+    ): Foxx.SessionsMiddleware;
     export = sessionsMiddleware;
 }
 
@@ -1386,14 +1434,11 @@ declare module "@arangodb/foxx/sessions/storages/collection" {
         pruneExpired?: boolean;
         autoUpdate?: boolean;
     }
-    interface CollectionStorage extends Foxx.SessionStorage {
-        prune: () => string[];
-    }
     function collectionStorage(
         options:
             | CollectionStorageOptions
             | CollectionStorageOptions["collection"]
-    ): CollectionStorage;
+    ): Foxx.CollectionSessionStorage;
     export = collectionStorage;
 }