@weclapp/sdk 2.0.0-dev.5 → 2.0.0-dev.51

package/dist/cli.js

@@ -1,19 +1,25 @@
 import { fileURLToPath } from 'url';
 import { resolve, dirname } from 'path';
-import { rmdir, stat, readFile, writeFile, rm, cp, mkdir } from 'fs/promises';
 import { rollup } from 'rollup';
 import terser from '@rollup/plugin-terser';
-import ts from 'rollup-plugin-ts';
+import ts from '@rollup/plugin-typescript';
 import indentString from 'indent-string';
 import { snakeCase, pascalCase, camelCase } from 'change-case';
 import chalk from 'chalk';
 import { OpenAPIV3 } from 'openapi-types';
 import { createHash } from 'crypto';
+import { stat, readFile, rm, cp, writeFile, mkdir } from 'fs/promises';
 import { config } from 'dotenv';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import pkg from '../package.json' with { type: 'json' };
 import prettyMs from 'pretty-ms';
 
+const currentDirname = () => {
+    // Go one level up as the CLI is inside a folder
+    return fileURLToPath(new URL('..', import.meta.url));
+};
+
 var Target;
 (function (Target) {
     Target["BROWSER_PROMISES"] = "browser";
@@ -34,15 +40,10 @@ const resolveBinaryType = (target) => {
     return isNodeTarget(target) ? 'Buffer' : 'Blob';
 };
 
-const currentDirname = () => {
-    // Go one level up as the CLI is inside a folder
-    return fileURLToPath(new URL('..', import.meta.url));
-};
-
-const tsconfig = resolve(currentDirname(), './tsconfig.lib.json');
-const resolveGlobals = (...globals) => Object.fromEntries(globals.map(v => [v, '*']));
+const tsconfig = resolve(currentDirname(), './tsconfig.sdk.json');
+const resolveGlobals = (...globals) => Object.fromEntries(globals.map((v) => [v, '*']));
 const generateOutput = (config) => ({
-    sourcemap: true,
+    sourcemap: false,
     banner: `/* weclapp sdk */`,
     ...config
 });
@@ -61,35 +62,22 @@ const bundle = async (workingDirectory, target) => {
             globals: resolveGlobals('node-fetch', 'url')
         })
     ];
-    // Remove build dir
-    await rmdir(dist()).catch(() => void 0);
     const bundles = {
         [Target.BROWSER_PROMISES]: () => ({
-            input: src('browser.ts'),
+            input: src('index.ts'),
+            plugins: [ts({ tsconfig, declarationDir: dist(), filterRoot: src() }), terser()],
             output: [
-                generateOutput({
-                    file: dist('index.cjs'),
-                    name: 'Weclapp',
-                    format: 'umd'
-                }),
                 generateOutput({
                     file: dist('index.js'),
                     format: 'es'
                 })
-            ],
-            plugins: [ts({ tsconfig }), terser()]
+            ]
         }),
         [Target.BROWSER_RX]: () => ({
+            input: src('index.ts'),
+            plugins: [ts({ tsconfig, declarationDir: dist(), filterRoot: src() }), terser()],
             external: ['rxjs'],
-            input: src('browser.rx.ts'),
-            plugins: [ts({ tsconfig }), terser()],
             output: [
-                generateOutput({
-                    file: dist('index.cjs'),
-                    name: 'Weclapp',
-                    format: 'umd',
-                    globals: resolveGlobals('rxjs')
-                }),
                 generateOutput({
                     file: dist('index.js'),
                     format: 'es',
@@ -98,16 +86,16 @@ const bundle = async (workingDirectory, target) => {
             ]
         }),
         [Target.NODE_PROMISES]: () => ({
-            input: src('node.ts'),
-            output: generateNodeOutput(),
+            input: src('index.ts'),
+            plugins: [ts({ tsconfig, declarationDir: dist(), filterRoot: src() }), terser()],
             external: ['node-fetch', 'url'],
-            plugins: [ts({ tsconfig })]
+            output: generateNodeOutput()
         }),
         [Target.NODE_RX]: () => ({
-            input: src('node.rx.ts'),
-            output: generateNodeOutput(),
+            input: src('index.ts'),
+            plugins: [ts({ tsconfig, declarationDir: dist(), filterRoot: src() }), terser()],
             external: ['node-fetch', 'url', 'rxjs'],
-            plugins: [ts({ tsconfig })]
+            output: generateNodeOutput()
         })
     };
     const config = bundles[target]();
@@ -139,14 +127,26 @@ const indent = (s, level = 1) => {
 };
 
 const generateStatements = (...statements) => statements
-    .map(v => v.trim())
-    .filter(v => v.length)
+    .map((v) => v.trim())
+    .filter((v) => v.length)
     .join('\n\n');
 const generateBlockStatements = (...statements) => `{\n${indent(generateStatements(...statements))}\n}`;
 
-var root = "export type RequestPayloadMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';\n\nexport interface RequestPayload {\n    method?: RequestPayloadMethod;\n    query?: Record<string, any>;\n    body?: any;\n    unwrap?: boolean;\n    forceBlob?: boolean;\n}\n\nexport interface ServiceConfig {\n\n    // Your API-Key, this is optional in the sense of if you omit this, and you're in a browser, the\n    // cookie-authentication (include-credentials) will be used.\n    key?: string;\n\n    // Your domain, if omitted location.host will be used.\n    host?: string;\n\n    // If you want to use https, defaults to true.\n    secure?: boolean;\n\n    // Optional request/response interceptors.\n    interceptors?: {\n\n        // Takes the generated request, you can either return a new request,\n        // a response (which will be taken as \"the\" response) or nothing.\n        // The payload contains the raw input generated by the SDK.\n        request?: (request: Request, payload: RequestPayload) => Request | Response | void | Promise<Request | Response | void>;\n\n        // Takes the response. This can either be the one from the server or an\n        // artificially-crafted one by the request interceptor.\n        response?: (response: Response) => Response | void | Promise<Response | void>;\n    };\n}\n\nlet globalConfig: ServiceConfig | undefined;\nexport const getGlobalConfig = (): ServiceConfig | undefined => globalConfig;\nexport const setGlobalConfig = (cfg?: ServiceConfig) => globalConfig = cfg;\n\nexport const raw = async (\n    cfg: ServiceConfig | undefined = globalConfig,\n    endpoint: string,\n    payload: RequestPayload = {}\n): Promise<any> => {\n    if (!cfg) {\n        throw new Error(`ServiceConfig missing.`);\n    }\n\n    cfg = {\n        ...globalConfig, ...cfg,\n        interceptors: {...globalConfig?.interceptors, ...cfg?.interceptors}\n    };\n\n    const isBinaryData = payload.body instanceof resolveBinaryObject();\n    const params = new URLSearchParams(Object.entries(payload.query ?? {}).filter(v => v[1] !== undefined));\n    const protocol = (cfg.secure ?? true) ? 'https' : 'http';\n\n    const interceptRequest = cfg.interceptors?.request ?? (v => v);\n    const interceptResponse = cfg.interceptors?.response ?? (v => v);\n\n    let host = cfg.host?.replace(/^https?:\\/\\//, '');\n    if (!host && typeof location !== 'undefined') {\n        host = location.host;\n    }\n\n    if (!host) {\n        throw new Error('Please specify a domain');\n    }\n\n    const request = new Request(`${protocol}://${host}/webapp/api/v1${endpoint}?${params}`, {\n        ...(payload.body && {\n            body: isBinaryData\n                ? payload.body\n                : JSON.stringify(payload.body, (key, value) => value === undefined ? null : value)\n        }),\n        ...(!cfg.key && {credentials: 'same-origin'}),\n        method: payload.method ?? 'get',\n        headers: {\n            'Accept': 'application/json',\n            ...(cfg.key && {'AuthenticationToken': cfg.key}),\n            ...(!isBinaryData && {'Content-Type': 'application/json'})\n        }\n    });\n\n    let res = await interceptRequest(request, payload) ?? request;\n    if (!(res instanceof Response)) {\n        res = await fetch(res);\n    }\n\n    res = await interceptResponse(res) ?? res;\n    const data = (!payload.forceBlob || !res.ok) && res.headers?.get('content-type')?.includes('application/json') ?\n        await res.json() : await res.blob();\n\n    // Check if response was successful\n    if (!res.ok) {\n        return Promise.reject(data);\n    }\n\n    return payload.unwrap ? data.result : data;\n};\n\nconst _count = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string,\n    query?: CountQuery<any> & {params?: Record<any, any>}\n) => wrapResponse(() => raw(cfg, endpoint, {\n    unwrap: true,\n    query: {\n        ...flattenFilter(query?.filter),\n        ...flattenOrFilter(query?.or),\n        ...query?.params\n    }\n}));\n\nconst _some = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string,\n    query?: SomeQuery<any, any, any, any, any> & {params?: Record<any, any>}\n) => wrapResponse(() => raw(cfg, endpoint, {\n        query: {\n            serializeNulls: query?.serializeNulls,\n            additionalProperties: query?.properties?.join(','),\n            properties: query?.select ? flattenSelect(query.select).join(',') : undefined,\n            includeReferencedEntities: query?.include ? Object.keys(query.include).join(',') : undefined,\n            ...flattenOrFilter(query?.or),\n            ...flattenFilter(query?.filter),\n            ...flattenSort(query?.sort),\n            ...query?.params,\n            ...query?.pagination\n        }\n    }).then(data => ({\n        entities: data.result,\n        references: data.referencedEntities ?? {},\n        properties: data.additionalProperties ?? {}\n    }))\n);\n\nconst _remove = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string,\n    {dryRun = false}: RemoveQuery = {}\n) => wrapResponse(() => raw(cfg, endpoint, {\n    method: 'DELETE',\n    query: {dryRun}\n}).then(() => undefined));\n\nconst _create = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string,\n    data: any\n) => wrapResponse(() => raw(cfg, endpoint, {\n    method: 'POST',\n    body: data\n}));\n\nconst _update = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string,\n    data: any,\n    {ignoreMissingProperties = true, dryRun = false}: UpdateQuery = {}\n) => wrapResponse(() => raw(cfg, endpoint, {\n    method: 'PUT',\n    body: data,\n    query: {ignoreMissingProperties, dryRun}\n}));\n\nconst _unique = (\n    cfg: ServiceConfig | undefined,\n    endpoint: string,\n    query?: UniqueQuery\n) => wrapResponse(() => raw(cfg, endpoint, {query}));\n\nconst _generic = (\n    cfg: ServiceConfig | undefined,\n    method: RequestPayloadMethod,\n    endpoint: string,\n    payload?: GenericQuery<any, any>,\n    forceBlob?: boolean\n) => wrapResponse(() => raw(cfg, endpoint, {\n    method,\n    forceBlob,\n    body: payload?.body,\n    query: payload?.params\n}));\n";
+var globalConfig = "export type RequestPayloadMethod =\n  | 'GET'\n  | 'HEAD'\n  | 'POST'\n  | 'PUT'\n  | 'DELETE'\n  | 'CONNECT'\n  | 'OPTIONS'\n  | 'TRACE'\n  | 'PATCH';\n\nexport interface RequestPayload {\n  method?: RequestPayloadMethod;\n  query?: Record<string, any>;\n  body?: any;\n  unwrap?: boolean;\n  forceBlob?: boolean;\n}\n\nexport interface ServiceConfig {\n  // Your API-Key, this is optional in the sense of if you omit this, and you're in a browser, the\n  // cookie-authentication (include-credentials) will be used.\n  key?: string;\n\n  // Your domain, if omitted location.host will be used (browser env).\n  host?: string;\n\n  // If you want to use https, defaults to location.protocol (browser env).\n  secure?: boolean;\n\n  // If you want that some and count requests are bundled into multi requests.\n  multiRequest?: boolean;\n\n  // If you want that the ignoreMissingProperties parameter to be set to true for every post request.\n  ignoreMissingProperties?: boolean;\n\n  // Optional request/response interceptors.\n  interceptors?: {\n    // Takes the generated request, you can either return a new request,\n    // a response (which will be taken as \"the\" response) or nothing.\n    // The payload contains the raw input generated by the SDK.\n    request?: (\n      request: Request,\n      payload: RequestPayload\n    ) => Request | Response | void | Promise<Request | Response | void>;\n\n    // Takes the response. This can either be the one from the server or an\n    // artificially-crafted one by the request interceptor.\n    response?: (response: Response) => Response | void | Promise<Response | void>;\n  };\n\n  // Whether POST should be used instead of GET for some() and count() operations\n  usePost?: boolean;\n}\n\nexport interface RequestOptions {\n    signal?: AbortSignal;\n}\n\ntype ServiceConfigWithoutMultiRequest = Omit<ServiceConfig, 'multiRequest'>;\n\nlet globalConfig: ServiceConfig | undefined;\nexport const getGlobalConfig = (): ServiceConfig | undefined => globalConfig;\nexport const setGlobalConfig = (cfg?: ServiceConfig) => (globalConfig = cfg);\n\nexport const getHost = (cfg: ServiceConfig) => {\n  let host = cfg.host?.replace(/^https?:\\/\\//, '');\n  if (!host && typeof location !== 'undefined') {\n    host = location.host;\n  }\n\n  if (!host) {\n    throw new Error('Please specify a host');\n  }\n\n  return host;\n};\n\nexport const getProtocol = (cfg: ServiceConfig) => {\n  const protocol =\n    cfg.secure !== undefined\n      ? cfg.secure\n        ? 'https:'\n        : 'http:'\n      : typeof location !== 'undefined'\n        ? location.protocol\n        : undefined;\n\n  if (!protocol) {\n    throw new Error('Please specify a protocol (secure)');\n  }\n\n  return protocol;\n};\n";
+
+var multiRequest = "type RequestTask = {\n  uri: string;\n  resolve: (result: unknown) => void;\n  reject: (error: unknown) => void;\n};\n\ntype BatchRequestTask = RequestTask & {\n  settled: boolean;\n};\n\ntype MultiRequestResponse = {\n  status: number;\n  body: object;\n};\n\nlet microtaskQueued: boolean = false;\nconst tasksSet: Set<RequestTask> = new Set<RequestTask>();\n\nconst SQUARE_BRACKET_OPEN = '['.charCodeAt(0);\nconst COMMA = ','.charCodeAt(0);\nconst DECODER = new TextDecoder();\n\nconst readNextResponse = (bytes: Uint8Array<ArrayBuffer>) => {\n  let headerStart: number | undefined = undefined;\n  let commasSeen = 0;\n\n  for (let i = 0; i < bytes.length; i++) {\n    const byte = bytes[i];\n    if (headerStart === undefined) {\n      if (byte === SQUARE_BRACKET_OPEN || byte === COMMA) {\n        headerStart = i + 1;\n      }\n    } else {\n      if (byte === COMMA) {\n        commasSeen++;\n      }\n      if (commasSeen === 2) {\n        const headerArrayString = `[${DECODER.decode(bytes.subarray(headerStart, i))}]`;\n        const [index, jsonLength] = JSON.parse(headerArrayString);\n        if (!(typeof index === 'number') || !(typeof jsonLength === 'number')) {\n          throw new Error(`unexpected header: ${headerArrayString}`);\n        }\n\n        const endIndex = i + 1 + jsonLength;\n        if (endIndex > bytes.length) {\n          // not all bytes available yet\n          return undefined;\n        }\n        const jsonString = DECODER.decode(bytes.subarray(i + 1, endIndex));\n        const data = JSON.parse(jsonString) as MultiRequestResponse;\n        return {\n          index,\n          data,\n          remainingBytes: bytes.subarray(endIndex)\n        };\n      }\n    }\n  }\n  return undefined;\n};\n\nconst fetchMultiRequest = async (requests: string[]) => {\n  const cfg = getGlobalConfig();\n\n  if (!cfg) {\n    throw new Error(`ServiceConfig missing.`);\n  }\n\n  const host = getHost(cfg);\n  const protocol = getProtocol(cfg);\n\n  return await fetch(`${protocol}//${host}/webapp/api/v2/batch/query`, {\n    method: 'POST',\n    headers: {\n      'Content-Type': 'application/json',\n      ...(cfg.key && { AuthenticationToken: cfg.key })\n    },\n    body: JSON.stringify({ requests })\n  });\n};\n\nconst rejectTasks = (tasks: BatchRequestTask[], error: unknown) => {\n  for (const task of tasks) {\n    if (!task.settled) {\n      task.reject(error);\n    }\n  }\n};\n\nconst processStream = (\n  { value: chunk, done }: ReadableStreamReadResult<Uint8Array>,\n  remainingBytes: Uint8Array,\n  reader: ReadableStreamDefaultReader<Uint8Array>,\n  tasks: BatchRequestTask[]\n) => {\n  if (done) {\n    return;\n  }\n  if (chunk) {\n    let bytes = new Uint8Array(remainingBytes.length + chunk.length);\n    bytes.set(remainingBytes);\n    bytes.set(chunk, remainingBytes.length);\n\n    while (bytes.length) {\n      const result = readNextResponse(bytes);\n      if (!result) {\n        break;\n      }\n      const task = tasks[result.index];\n      if (result.data.status >= 100 && result.data.status < 400) {\n        task.resolve({\n          ...result.data.body\n        });\n      } else {\n        task.reject({\n          ...result.data.body\n        });\n      }\n      task.settled = true;\n      bytes = result.remainingBytes;\n    }\n    reader\n      .read()\n      .then((readResult) => processStream(readResult, bytes, reader, tasks))\n      .catch((error) => rejectTasks(tasks, error));\n  }\n};\n\nconst batch = async (tasks: BatchRequestTask[]) => {\n  try {\n    const requests = tasks.map(({ uri }) => uri);\n    const resp = await fetchMultiRequest(requests);\n    const reader = resp.body?.getReader();\n\n    if (!reader) {\n      throw new Error('Stream reader is undefined');\n    }\n    reader\n      .read()\n      .then((readResult) => processStream(readResult, new Uint8Array(0), reader, tasks))\n      .catch((error) => rejectTasks(tasks, error));\n  } catch (e) {\n    rejectTasks(tasks, e);\n    throw e;\n  }\n};\n\nconst addTask = (task: RequestTask) => {\n  tasksSet.add(task);\n\n  if (!microtaskQueued) {\n    queueMicrotask(() => {\n      microtaskQueued = false;\n      if (tasksSet.size > 0) {\n        const batchTasks = Array.from(tasksSet).map((task) => ({ ...task, settled: false }));\n        void batch(batchTasks);\n        tasksSet.clear();\n      }\n    });\n    microtaskQueued = true;\n  }\n};\n\nconst addRequest = (uri: string) => new Promise((resolve, reject) => addTask({ uri, resolve, reject }));\n";
+
+var queriesWithFilter = "export type EqualityOperator = 'EQ' | 'NE';\n\nexport type ComparisonOperator =\n  | 'LT'\n  | 'GT'\n  | 'LE'\n  | 'GE'\n  | 'LIKE'\n  | 'ILIKE'\n  | 'NOT_LIKE'\n  | 'NOT_ILIKE'\n  | 'IEQ'\n  | 'NOT_IEQ';\n\nexport type ArrayOperator = 'IN' | 'NOT_IN';\n\nexport type Operator = EqualityOperator | ComparisonOperator | ArrayOperator;\n\nexport type MapOperators<T> = { [K in EqualityOperator]?: T | null } & { [K in ComparisonOperator]?: T } & {\n  [K in ArrayOperator]?: T[];\n};\n\nexport type QueryFilter<T> = {\n  [P in keyof T]?: T[P] extends Array<infer U> | undefined\n    ? U extends Record<any, any>\n      ? QueryFilter<U>\n      : MapOperators<U>\n    : T[P] extends Record<any, any> | undefined\n      ? QueryFilter<T[P]>\n      : MapOperators<T[P]>;\n};\n\nexport type CountQuery<F> = {\n  filter?: QueryFilter<F>;\n  or?: (QueryFilter<F> & CustomAttributeFilter)[];\n};\n\nexport type SomeQuery<E, F, I, P> = {\n  serializeNulls?: boolean;\n  include?: QuerySelect<I>;\n  properties?: P;\n  filter?: QueryFilter<F> & CustomAttributeFilter;\n  select?: QuerySelect<E>;\n  or?: (QueryFilter<F> & CustomAttributeFilter)[];\n  sort?: Sort<E>[];\n  pagination?: Pagination;\n};\n\nconst equality: string[] = ['EQ', 'NE', 'IEQ', 'NOT_IEQ'];\n\nconst simple: string[] = [...equality, 'LT', 'GT', 'LE', 'GE', 'LIKE', 'NOT_LIKE', 'ILIKE', 'NOT_ILIKE'];\n\nconst array: string[] = ['IN', 'NOT_IN'];\n\nconst filterMap: Record<Operator, string> = {\n  EQ: 'eq',\n  NE: 'ne',\n  LT: 'lt',\n  GT: 'gt',\n  LE: 'le',\n  GE: 'ge',\n  LIKE: 'like',\n  NOT_LIKE: 'notlike',\n  ILIKE: 'ilike',\n  NOT_ILIKE: 'notilike',\n  IN: 'in',\n  NOT_IN: 'notin',\n  IEQ: 'ieq',\n  NOT_IEQ: 'notieq'\n};\n\nconst flattenCustomAttributes = (obj: CustomAttributeFilter = {}): [string, string][] => {\n  const entries: [string, string][] = [];\n\n  for (const [id, filter] of Object.entries(obj)) {\n    const key = `customAttribute${id}`;\n\n    if (typeof filter === 'object') {\n      for (const [prop, value] of Object.entries(filter)) {\n        entries.push([`${key}.${prop}-eq`, String(value)]);\n      }\n    } else if (filter !== undefined) {\n      entries.push([`${key}-eq`, String(filter)]);\n    }\n  }\n\n  return entries;\n};\n\nconst flatten = (obj: QueryFilter<any> = {}): [string, string][] => {\n  const entries: [string, string][] = [];\n\n  for (const [prop, propValue] of Object.entries(obj)) {\n    for (const [filter, value] of Object.entries(propValue as object)) {\n      if (value === undefined) continue;\n\n      if (simple.includes(filter) || array.includes(filter)) {\n        if (value === null && equality.includes(filter)) {\n          entries.push([`${prop}-${filter === 'EQ' ? 'null' : 'notnull'}`, '']);\n        } else {\n          entries.push([`${prop}-${filterMap[filter as Operator]}`, value]);\n        }\n      } else {\n        entries.push(\n          ...(flatten(propValue as QueryFilter<any>).map((v) => [`${prop}.${v[0]}`, v[1]]) as [string, string][])\n        );\n        break;\n      }\n    }\n  }\n\n  return entries;\n};\n\nconst flattenFilter = (obj: QueryFilter<any> = {}): Record<string, string> => {\n  const filter: [string, any][] = [],\n    customAttributes: [string, any][] = [];\n\n  Object.entries(obj).forEach((value) => {\n    (value[0].match(/^\\d+$/) ? customAttributes : filter).push(value);\n  });\n\n  return Object.fromEntries([\n    ...flatten(Object.fromEntries(filter)),\n    ...flattenCustomAttributes(Object.fromEntries(customAttributes) as CustomAttributeFilter)\n  ]);\n};\n\nconst flattenOrFilter = (obj: QueryFilter<any>[] = []): Record<string, string> => {\n  const entries: [string, any][] = [];\n\n  for (let i = 0; i < obj.length; i++) {\n    entries.push(...(flatten(obj[i]).map((v) => [`or${i || ''}-${v[0]}`, v[1]]) as [string, string][]));\n  }\n\n  return Object.fromEntries(entries);\n};\n\nconst _count = (\n  cfg: ServiceConfig | undefined,\n  endpoint: string,\n  query?: CountQuery<any> & { params?: Record<any, any> },\n  requestOptions?: RequestOptions\n) =>\n{\n    const usePost = cfg?.usePost ?? globalConfig?.usePost\n    const payload = {\n      ...flattenFilter(query?.filter),\n      ...flattenOrFilter(query?.or),\n      ...query?.params\n    }\n\n    return wrapResponse(() =>\n      raw(cfg, endpoint, {\n        method: usePost ? 'POST' : 'GET',\n        unwrap: true,\n        ...(usePost ? { body: payload } : { query: payload })\n      }, requestOptions)\n    )\n  };\n\nconst _some = (\n  cfg: ServiceConfig | undefined,\n  endpoint: string,\n  query?: SomeQuery<any, any, any, any> & { params?: Record<any, any> },\n  requestOptions?: RequestOptions\n) =>\n{\n  const usePost = cfg?.usePost ?? globalConfig?.usePost\n  const payload = {\n      serializeNulls: query?.serializeNulls,\n      additionalProperties: query?.properties?.join(','),\n      properties: query?.select ? flattenSelect(query.select).join(',') : undefined,\n      includeReferencedEntities: query?.include ? Object.keys(query.include).join(',') : undefined,\n      ...flattenOrFilter(query?.or),\n      ...flattenFilter(query?.filter),\n      ...flattenSort(query?.sort),\n      ...query?.params,\n      ...query?.pagination\n  }\n\n   return wrapResponse(() =>\n      raw(cfg, usePost ? `${endpoint}/query` : endpoint, {\n        method: usePost ? 'POST' : 'GET',\n        ...(usePost ? { body: payload } : { query: payload })\n      }, requestOptions).then((data) => ({\n        entities: data.result,\n        references: data.referencedEntities ?? {},\n        properties: data.additionalProperties ?? {}\n      }))\n    )\n  };\n";
 
-var types = "export type DeepPartial<T> = T extends object ? {\n    [P in keyof T]?: DeepPartial<T[P]>;\n} : T;\n\n// Filter properties\nexport type EqualityOperators = 'EQ' | 'NE';\nexport type ComparisonOperators = 'LT' | 'GT' | 'LE' | 'GE' | 'LIKE' | 'ILIKE' | 'NOT_LIKE' | 'NOT_ILIKE';\nexport type ArrayOperators = 'IN' | 'NOT_IN';\nexport type Operator = EqualityOperators | ComparisonOperators | ArrayOperators;\n\nexport type MapOperators<T> = { [K in EqualityOperators]?: T | null; } &\n    { [K in ComparisonOperators]?: T; } &\n    { [K in ArrayOperators]?: T[]; };\n\nexport type QueryFilter<T> = {\n    [P in keyof T]?:\n        T[P] extends Array<infer U> | undefined ?\n            U extends Record<any, any> ? QueryFilter<U> : MapOperators<U> :\n                T[P] extends Record<any, any> | undefined ? QueryFilter<T[P]> : MapOperators<T[P]>;\n};\n\nexport type Sort<T> = {\n    [K in keyof T]?: {\n        [V in keyof T]?:\n            V extends K ?\n                T[V] extends Array<infer U> | undefined ?\n                    U extends object ?\n                        Sort<U> : never :\n                            T[V] extends object | undefined ?\n                                Sort<T[V]> : 'asc' | 'desc' : never;\n    };\n}[keyof T];\n\n// Select properties\nexport type CustomAttributeFilter = {\n    [K in number]: string | number | boolean |\n    {id: string;} |\n    {entityName: string; entityId: string;};\n}\n\nexport type QuerySelect<T> = {\n    [P in keyof T]?:\n        T[P] extends Array<infer U> | undefined ? (QuerySelect<U> | boolean) :\n            T[P] extends Record<any, any> | undefined ? (QuerySelect<T[P]> | boolean) : boolean;\n}\n\nexport type Select<T, Q extends (QuerySelect<T> | undefined)> = Q extends QuerySelect<T> ? {\n\n    // Filter out excluded properties beforehand\n    [P in keyof T as Q[P] extends boolean ? P : Q[P] extends object ? P : never]:\n\n    // Property\n    Q[P] extends true ? T[P] :\n\n        // Array\n        T[P] extends Array<infer U> ? Select<U, Q[P] & QuerySelect<any>>[] :\n\n            // Object\n            T[P] extends Record<any, any> ? Select<T[P], Q[P] & QuerySelect<any>> : never\n} : undefined;\n\nexport type MapKeys<T, S extends Record<keyof T, string>> = {\n    [K in keyof T as S[K]]: T[K];\n};\n\n// Endpoint configurations\nexport type CountQuery<F> = {\n    filter?: QueryFilter<F>;\n    or?: (QueryFilter<F> & CustomAttributeFilter)[];\n};\n\nexport type Pagination = {\n    page: number;\n    pageSize: number;\n};\n\nexport type SomeQuery<\n    E, // Entity\n    F, // Entity filter\n    I extends (QuerySelect<any> | undefined), // Select for referenced entities\n    S extends (QuerySelect<any> | undefined), // Select for entity properties\n    P extends string[] // Select for additional properties\n> = {\n    serializeNulls?: boolean;\n    include?: I;\n    properties?: P\n    filter?: QueryFilter<F> & CustomAttributeFilter;\n    select?: S;\n    or?: (QueryFilter<F> & CustomAttributeFilter)[];\n    sort?: Sort<E>[];\n    pagination?: Pagination;\n};\n\nexport type UniqueQuery = {\n    serializeNulls?: boolean;\n}\n\nexport type SomeQueryReturn<\n    E, // Entity\n    R, // Map of referenced-entity names to the type\n    M, // Map of referenced-entity-id names to their entity name\n    I extends (QuerySelect<any> | undefined), // Select for referenced entities\n    S extends (QuerySelect<any> | undefined), // Select for entity properties\n    P // Additional properties\n> = {\n    entities: (S extends QuerySelect<E> ? Select<E, S> : E)[];\n    references: I extends QuerySelect<R> ? Partial<MapKeys<Select<R, I>, M & Record<any, any>>> : {};\n    properties: P\n};\n\nexport type GenericQuery<P, B> = {\n    params?: P;\n    body?: B;\n};\n\nexport type UpdateQuery = {\n    ignoreMissingProperties?: boolean;\n    dryRun?: boolean;\n}\n\nexport type RemoveQuery = {\n    dryRun?: boolean;\n}\n\n// Entity meta types\nexport type WEntityPropertyMeta = (\n    { type: 'string'; format?: 'decimal' | 'html'; entity?: WEntity; service?: WService; } |\n    { type: 'integer'; format: 'int32' | 'int64' | 'duration' | 'date' | 'timestamp'; } |\n    { type: 'array'; format: 'reference'; entity: WEntity; service?: WService; } |\n    { type: 'array'; format: 'reference'; enum: WEnum; } |\n    { type: 'array'; format: 'string'; } |\n    { type: 'number'; format: 'double'; } |\n    { type: 'reference'; entity: WEntity; } |\n    { type: 'reference'; enum: WEnum; } |\n    { type: 'boolean'; } |\n    { type: 'object'; }\n);\n\n// Utils\nconst equality: string[] = ['EQ', 'NE'];\nconst simple: string[] = [...equality, 'LT', 'GT', 'LE', 'GE', 'LIKE', 'NOT_LIKE', 'ILIKE', 'NOT_ILIKE'];\nconst array: string[] = ['IN', 'NOT_IN'];\nconst filterMap: Record<Operator, string> = {\n    EQ: 'eq',\n    NE: 'ne',\n    LT: 'lt',\n    GT: 'gt',\n    LE: 'le',\n    GE: 'ge',\n    LIKE: 'like',\n    NOT_LIKE: 'notlike',\n    ILIKE: 'ilike',\n    NOT_ILIKE: 'notilike',\n    IN: 'in',\n    NOT_IN: 'notin'\n};\n\nconst flattenCustomAttributes = (obj: CustomAttributeFilter = {}): [string, string][] => {\n    const entries: [string, string][] = [];\n\n    for (const [id, filter] of Object.entries(obj)) {\n        const key = `customAttribute${id}`;\n\n        if (typeof filter === 'object') {\n            for (const [prop, value] of Object.entries(filter)) {\n                entries.push([`${key}.${prop}-eq`, String(value)]);\n            }\n        } else if (filter !== undefined) {\n            entries.push([`${key}-eq`, String(filter)]);\n        }\n    }\n\n    return entries;\n};\n\nconst flatten = (obj: QueryFilter<any> = {}): [string, string][] => {\n    const entries: [string, string][] = [];\n\n    for (const [prop, propValue] of Object.entries(obj)) {\n        for (const [filter, value] of Object.entries(propValue as object)) {\n            if (value === undefined) continue;\n\n            if (simple.includes(filter)) {\n                if (value === null && equality.includes(filter)) {\n                    entries.push([`${prop}-${filter === 'EQ' ? 'null' : 'notnull'}`, '']);\n                } else {\n                    entries.push([`${prop}-${filterMap[filter as Operator]}`, value]);\n                }\n            } else if (array.includes(filter)) {\n                entries.push([\n                    `${prop}-${filterMap[filter as Operator]}`,\n                    `[${value.map((v: string | number) => typeof v === 'string' ? `\"${v}\"` : v)}]`\n                ]);\n            } else {\n                entries.push(\n                    ...flatten(propValue as QueryFilter<any>)\n                        .map(v => [`${prop}.${v[0]}`, v[1]]) as [string, string][]\n                );\n                break;\n            }\n        }\n    }\n\n    return entries;\n};\n\nconst flattenFilter = (obj: QueryFilter<any> = {}): Record<string, string> => {\n    const filter: [string, any][] = [], customAttributes: [string, any][] = [];\n\n    Object.entries(obj).forEach(value => {\n        (value[0].match(/^\\d+$/) ? customAttributes : filter).push(value);\n    });\n\n    return Object.fromEntries([\n        ...flatten(Object.fromEntries(filter)),\n        ...flattenCustomAttributes(Object.fromEntries(customAttributes) as CustomAttributeFilter)\n    ]);\n};\n\nconst flattenOrFilter = (obj: QueryFilter<any>[] = []): Record<string, string> => {\n    const entries: [string, any][] = [];\n\n    for (let i = 0; i < obj.length; i++) {\n        entries.push(\n            ...flatten(obj[i])\n                .map(v => [`or${i || ''}-${v[0]}`, v[1]]) as [string, string][]\n        );\n    }\n\n    return Object.fromEntries(entries);\n};\n\nconst flattenSelect = (obj: Select<any, any> = {}): string[] => {\n    const entries: string[] = [];\n\n    for (const [prop, value] of Object.entries(obj)) {\n        if (typeof value === 'object' && value) {\n            entries.push(...flattenSelect(value).map(v => `${prop}.${v}`));\n        } else if (value) {\n            entries.push(prop);\n        }\n    }\n\n    return entries;\n};\n\nexport const flattenSort = (obj: Sort<any>[] = []): {sort?: string} => {\n    const flatten = (obj: Sort<any>, base = ''): string | undefined => {\n        const [key, value] = Object.entries(obj ?? {})[0] ?? [];\n\n        if (key && value) {\n            const path = base + key;\n\n            if (typeof value === 'object') {\n                return flatten(value, path ? `${path}.` : '');\n            } else if (['asc', 'desc'].includes(value)) {\n                return `${value === 'desc' ? '-' : ''}${path}`;\n            }\n        }\n\n        return undefined;\n    };\n\n    const sorts = obj.map(v => flatten(v)).filter(Boolean);\n    return sorts.length ? {sort: sorts.join(',')} : {};\n};\n";
+var queriesWithQueryLanguage = "export type ComparisonOperator =\n  | 'EQ'\n  | 'NE'\n  | 'LT'\n  | 'GT'\n  | 'LE'\n  | 'GE'\n  | 'LIKE';\n\nexport type ArrayOperator = 'IN';\n\nexport type NullOperator = 'NULL';\n\nexport type Operator = ComparisonOperator | ArrayOperator | NullOperator;\n\nexport type ModifierFunction = 'lower';\n\nexport type MapOperators<T> =\n  | ({ [K in ComparisonOperator]?: T } & { [K in ArrayOperator]?: T[] } & {\n      [K in NullOperator]?: never } & {\n      [K in ModifierFunction]?: boolean\n    })\n  | ({ [K in ComparisonOperator]?: T } & { [K in ArrayOperator]?: T[] } & {\n      [K in NullOperator]?: boolean } & {\n      [K in ModifierFunction]?: never\n    });\n\nexport type SingleFilterExpr<T> = {\n  [P in keyof T]?: T[P] extends Array<infer U> | undefined\n    ? U extends Record<any, any>\n      ? SingleFilterExpr<U> | { NOT?: SingleFilterExpr<U> }\n      : MapOperators<U>\n    : T[P] extends Record<any, any> | undefined\n      ? SingleFilterExpr<T[P]> | { NOT?: SingleFilterExpr<T[P]> }\n      : MapOperators<T[P]>;\n};\n\nexport type QueryFilter<T> = SingleFilterExpr<T> & {\n  OR?: QueryFilter<T>[];\n  AND?: QueryFilter<T>[];\n  NOT?: QueryFilter<T>;\n};\n\nexport type CountQuery<F> = {\n  where?: QueryFilter<F>;\n};\n\nexport type SomeQuery<E, F, I, P> = {\n  serializeNulls?: boolean;\n  include?: QuerySelect<I>;\n  properties?: P;\n  where?: QueryFilter<F>;\n  select?: QuerySelect<E>;\n  sort?: Sort<E>[];\n  pagination?: Pagination;\n};\n\nconst comparisonOperatorList: ComparisonOperator[] = [\n  'EQ',\n  'NE',\n  'LT',\n  'GT',\n  'LE',\n  'GE',\n  'LIKE'\n];\n\nconst comparisonOperatorMap: Record<Operator, string> = {\n  EQ: '=',\n  NE: '!=',\n  LT: '<',\n  GT: '>',\n  LE: '<=',\n  GE: '>=',\n  LIKE: '~',\n  IN: 'in',\n  NULL: 'null'\n};\n\nconst modifierFunctionList: ModifierFunction[] = ['lower'];\n\nconst flattenWhere = (\n  obj: QueryFilter<any> = {},\n  nestedPaths: string[]\n): string[] => {\n  const entries: string[] = [];\n  for (const [prop, propValue] of Object.entries(obj)) {\n    const setModifiers = findAllModifierFunctions(propValue ?? {}, modifierFunctionList).filter(\n      (modifier) => modifier[1]\n    );\n    if (prop === 'OR') {\n      const flattedOr: string[][] = [];\n      for (let i = 0; i < (obj.OR?.length ?? 0); i++) {\n        flattedOr.push(flattenWhere(obj.OR?.[i], nestedPaths));\n      }\n      entries.push(\n        `(${flattedOr\n          .map((x) => {\n            const joined = x.join(' and ');\n\n            if (x.length > 1) {\n              return `(${joined})`;\n            } else {\n              return joined;\n            }\n          })\n          .join(' or ')})`\n      );\n    } else if (prop === 'AND') {\n      const flattedAnd: string[][] = [];\n      for (let i = 0; i < (obj.AND?.length ?? 0); i++) {\n        flattedAnd.push(flattenWhere(obj.AND?.[i], nestedPaths));\n      }\n      entries.push(\n        `(${flattedAnd\n          .map((x) => {\n            const joined = x.join(' and ');\n\n            if (x.length > 1) {\n              return `(${joined})`;\n            } else {\n              return joined;\n            }\n          })\n          .join(' and ')})`\n      );\n    } else if (prop === 'NOT') {\n      const flattedNot = flattenWhere(obj.NOT, nestedPaths);\n      entries.push(\n        `not ${flattedNot.length > 1 ? '(' : ''}${flattedNot.join(' and ')}${flattedNot.length > 1 ? ')' : ''}`\n      );\n    } else if (propValue) {\n      for (const [operator, value] of Object.entries(propValue)) {\n        if (value === undefined) continue;\n        if (comparisonOperatorList.includes(operator as ComparisonOperator)) {\n          entries.push(\n            `${setModifiers.reduce(\n              (acc, [first]) => `${first}(${acc})`,\n              nestedPaths.some((path) => path === prop) ? nestedPaths.join('.') : [...nestedPaths, prop].join('.')\n            )} ${comparisonOperatorMap[operator as Operator]} ${\n              typeof value === 'string'\n                ? setModifiers.reduce((acc, [first]) => `${first}(${acc})`, JSON.stringify(value))\n                : value\n            }`\n          );\n        } else if ((operator as Operator) === 'NULL') {\n          entries.push(\n            `${!value ? 'not ' : ''}${nestedPaths.some((path) => path === prop) ? nestedPaths.join('.') : [...nestedPaths, prop].join('.')} ${comparisonOperatorMap[operator as Operator]}`\n          );\n        } else if ((operator as Operator) === 'IN') {\n          if(value.length === 0) {\n            entries.push('1 = 0')\n          } else {\n            entries.push(\n              `${setModifiers.reduce(\n                (acc, [first]) => `${first}(${acc})`,\n                nestedPaths.some((path) => path === prop) ? nestedPaths.join('.') : [...nestedPaths, prop].join('.')\n              )} ${comparisonOperatorMap[operator as Operator]} [${value.map((v: string | number) =>\n                typeof v === 'string' ? setModifiers.reduce((acc, [first]) => `${first}(${acc})`, JSON.stringify(v)) : v\n              )}]`\n            );\n          }\n        } else if (\n          !modifierFunctionList.includes(operator as ModifierFunction)\n        ) {\n          entries.push(\n            ...flattenWhere(propValue as QueryFilter<any>, [\n              ...nestedPaths,\n              prop\n            ])\n          );\n          break;\n        }\n      }\n    }\n  }\n  return entries;\n};\n\nconst assembleFilterParam = (\n  obj: QueryFilter<any> = {}\n): Record<string, string> => {\n  const flattedFilter = flattenWhere(obj, []);\n  return flattedFilter.length ? { filter: flattedFilter.join(' and ') } : {};\n};\n\nconst findAllModifierFunctions = (\n  obj: Record<string, any>,\n  types: ModifierFunction[]\n) => {\n  const result: Record<string, any> = {};\n  for (const key in obj) {\n    if (types.includes(key as ModifierFunction)) {\n      result[key] = obj[key];\n    }\n  }\n  return Object.entries(result);\n};\n\nconst _count = (\n  cfg: ServiceConfig | undefined,\n  endpoint: string,\n  query?: CountQuery<any> & { params?: Record<any, any> },\n  requestOptions?: RequestOptions\n) =>\n  {\n    const usePost = cfg?.usePost ?? globalConfig?.usePost\n    const payload = {\n      ...assembleFilterParam(query?.where),\n      ...query?.params\n    }\n\n    return wrapResponse(() =>\n      raw(cfg, endpoint, {\n        unwrap: true,\n        method: usePost ? 'POST' : 'GET',\n        ...(usePost ? { body: payload } : { query: payload })\n      }, requestOptions)\n    )\n  };\n\nconst _some = (\n  cfg: ServiceConfig | undefined,\n  endpoint: string,\n  query?: SomeQuery<any, any, any, any> & { params?: Record<any, any> },\n  requestOptions?: RequestOptions\n) =>\n  {\n    const usePost = cfg?.usePost ?? globalConfig?.usePost\n    const payload = {\n      serializeNulls: query?.serializeNulls,\n      additionalProperties: query?.properties?.join(','),\n      properties: query?.select\n        ? flattenSelect(query.select).join(',')\n        : undefined,\n      includeReferencedEntities: query?.include\n        ? Object.keys(query.include).join(',')\n        : undefined,\n      ...assembleFilterParam(query?.where),\n      ...flattenSort(query?.sort),\n      ...query?.params,\n      ...query?.pagination\n    }\n\n    return wrapResponse(() =>\n      raw(cfg, usePost ? `${endpoint}/query` : endpoint, {\n        method: usePost ? 'POST' : 'GET',\n        ...(usePost ? { body: payload } : { query: payload })\n      }, requestOptions).then((data) => ({\n        entities: data.result,\n        references: data.referencedEntities ?? {},\n        properties: data.additionalProperties ?? {}\n      }))\n    )\n  };\n";
+
+var root = "export const raw = async (\n  cfg: ServiceConfig | undefined,\n  endpoint: string,\n  payload: RequestPayload = {},\n  requestOptions?: RequestOptions\n): Promise<any> => {\n  if (!cfg && !globalConfig) {\n    throw new Error(`ServiceConfig missing.`);\n  }\n\n  const localCfg = {\n    ...globalConfig,\n    ...cfg,\n    interceptors: { ...globalConfig?.interceptors, ...cfg?.interceptors }\n  };\n\n  const isBinaryData = payload.body instanceof resolveBinaryObject();\n  const params = new URLSearchParams(Object.entries(payload.query ?? {}).filter((v) => v[1] !== undefined)\n    .map(([key, value]) => [key, typeof value === 'string' ? value : JSON.stringify(value)])\n  );\n\n  const protocol = getProtocol(localCfg);\n\n  const interceptRequest = localCfg.interceptors?.request ?? ((v) => v);\n  const interceptResponse = localCfg.interceptors?.response ?? ((v) => v);\n\n  const host = getHost(localCfg);\n\n  let data;\n  if (!cfg && localCfg.multiRequest) {\n    let ep = endpoint;\n    if (endpoint.startsWith('/')) {\n      ep = endpoint.replace('/', '');\n    }\n    data = await addRequest(`${ep}?${params}`);\n  } else {\n    const request = new Request(`${protocol}//${host}/webapp/api/v${apiVersion}${endpoint}?${params}`, {\n      ...(payload.body && {\n        body: isBinaryData\n          ? payload.body\n          : JSON.stringify(payload.body, (_key, value) => (value === undefined ? null : value))\n      }),\n      ...(!localCfg.key && { credentials: 'same-origin' }),\n      method: payload.method ?? 'get',\n      headers: {\n        Accept: 'application/json',\n        ...(localCfg.key && { AuthenticationToken: localCfg.key }),\n        ...(!isBinaryData && { 'Content-Type': 'application/json' })\n      }\n    });\n    let res = (await interceptRequest(request, payload)) ?? request;\n    if (!(res instanceof Response)) {\n      res = requestOptions?.signal ?  await fetch(res, { signal: requestOptions.signal } ) : await fetch(res);\n    }\n    res = (await interceptResponse(res)) ?? res;\n\n    if (res.ok) {\n      data =\n        payload.forceBlob || !res.headers?.get('content-type')?.includes('application/json')\n          ? await res.blob()\n          : await res.json();\n    } else {\n      data = res.headers?.get('content-type')?.includes('application/json')\n          ? await res.json()\n          : res;\n    }\n\n    // Check if response was successful\n    if (!res.ok) {\n      return Promise.reject(data);\n    }\n  }\n\n  return payload.unwrap ? data.result : data;\n};\n\nconst _remove = (\n  cfg: ServiceConfigWithoutMultiRequest | undefined,\n  endpoint: string,\n  { dryRun = false }: RemoveQuery = {},\n    requestOptions?: RequestOptions\n) =>\n  wrapResponse(() =>\n    raw({ ...cfg, multiRequest: false }, endpoint, {\n      method: 'DELETE',\n      query: { dryRun }\n    }, requestOptions).then(() => undefined)\n  );\n\nconst _create = (cfg: ServiceConfigWithoutMultiRequest | undefined, endpoint: string, data: any, requestOptions?: RequestOptions) =>\n  wrapResponse(() =>\n    raw({ ...cfg, multiRequest: false }, endpoint, {\n      method: 'POST',\n      body: data\n    }, requestOptions)\n  );\n\nconst _update = (\n  cfg: ServiceConfigWithoutMultiRequest | undefined,\n  endpoint: string,\n  data: any,\n  { ignoreMissingProperties, dryRun = false }: UpdateQuery = {},\n  requestOptions?: RequestOptions\n) =>\n  wrapResponse(() =>\n    raw({ ...cfg, multiRequest: false }, endpoint, {\n      method: 'PUT',\n      body: data,\n      query: {\n        ignoreMissingProperties:\n          ignoreMissingProperties ?? cfg?.ignoreMissingProperties ?? globalConfig?.ignoreMissingProperties,\n        dryRun\n      }\n    }, requestOptions)\n  );\n\nconst _generic = (\n  cfg: ServiceConfigWithoutMultiRequest | undefined,\n  method: RequestPayloadMethod,\n  endpoint: string,\n  payload?: GenericQuery<any, any>,\n  forceBlob?: boolean,\n  requestOptions?: RequestOptions\n) =>\n{\n  const usePost = cfg?.usePost ?? globalConfig?.usePost\n  return wrapResponse(() =>\n    raw({ ...cfg, multiRequest: false }, endpoint, {\n      method: usePost ? 'POST' : method,\n      forceBlob,\n      ...(usePost && method === 'GET' ?\n        { body: { ...payload?.params } }\n        :\n        { body: payload?.body, query: payload?.params } )\n  }, requestOptions))\n};\n";
+
+var unique = "const _unique = (cfg: ServiceConfigWithoutMultiRequest | undefined, endpoint: string, query?: UniqueQuery, requestOptions?: RequestOptions) =>\n  wrapResponse(() => raw({ ...cfg, multiRequest: false }, endpoint, { query }, requestOptions));\n";
+
+var types = "export type DeepPartial<T> = T extends object\n  ? {\n      [P in keyof T]?: DeepPartial<T[P]>;\n    }\n  : T;\n\nexport type Sort<T> = {\n  [K in keyof T]?: {\n    [V in keyof T]?: V extends K\n      ? T[V] extends Array<infer U> | undefined\n        ? U extends object\n          ? Sort<U>\n          : never\n        : T[V] extends object | undefined\n          ? Sort<T[V]>\n          : 'asc' | 'desc'\n      : never;\n  };\n}[keyof T];\n\nexport type CustomAttributeFilter = {\n  [K in number]:| string | number | boolean | { id: string } | { entityName: string; entityId: string };\n};\n\nexport type QuerySelect<T> = {\n  [P in keyof T]?: T[P] extends Array<infer U> | undefined\n    ? QuerySelect<U> | boolean\n    : T[P] extends Record<any, any> | undefined\n      ? QuerySelect<T[P]> | boolean\n      : boolean;\n};\n\nexport type Select<T, Q extends QuerySelect<T> | undefined> =\n  Q extends QuerySelect<T>\n    ? {\n        // Filter out excluded properties beforehand\n        [P in keyof T as Q[P] extends boolean ? P : Q[P] extends object ? P : never]: // Property\n        Q[P] extends true\n          ? T[P]\n          : // Array\n            T[P] extends Array<infer U>\n            ? Select<U, Q[P] & QuerySelect<any>>[]\n            : // Object\n              T[P] extends Record<any, any>\n              ? Select<T[P], Q[P] & QuerySelect<any>>\n              : never;\n      }\n    : undefined;\n\nexport type MapKeys<T, S extends Record<keyof T, string>> = {\n  [K in keyof T as S[K]]: T[K];\n};\n\nexport type ValueOf<T> = T[keyof T];\n\nexport type Pagination = {\n  page: number;\n  pageSize: number;\n};\n\nexport type UniqueQuery = {\n  serializeNulls?: boolean;\n};\n\nexport type SomeQueryReturn<E, R, P> = {\n  entities: E[];\n  references?: R;\n  properties?: P[];\n};\n\nexport type GenericQuery<P, B> = {\n  params?: P;\n  body?: B;\n};\n\nexport type UpdateQuery = {\n  ignoreMissingProperties?: boolean;\n  dryRun?: boolean;\n};\n\nexport type RemoveQuery = {\n  dryRun?: boolean;\n};\n\nexport type WEntityPropertyMeta =\n  | {\n      type: 'string';\n      format?: 'decimal' | 'html' | 'email' | 'password';\n      maxLength?: number;\n      pattern?: string;\n      entity?: WEntity;\n      service?: WService;\n    }\n  | {\n      type: 'integer';\n      format: 'int32' | 'int64' | 'duration' | 'date' | 'timestamp';\n    }\n  | { type: 'array'; format: 'reference'; entity: WEntity; service?: WService }\n  | { type: 'array'; format: 'reference'; enum: WEnum }\n  | { type: 'array'; format: 'string' }\n  | { type: 'number'; format: 'double' }\n  | { type: 'reference'; entity: WEntity }\n  | { type: 'reference'; enum: WEnum }\n  | { type: 'boolean' }\n  | { type: 'object' };\n";
+
+var utils = "const flattenSelect = (obj: Select<any, any> = {}): string[] => {\n  const entries: string[] = [];\n\n  for (const [prop, value] of Object.entries(obj)) {\n    if (typeof value === 'object' && value) {\n      entries.push(...flattenSelect(value).map((v) => `${prop}.${v}`));\n    } else if (value) {\n      entries.push(prop);\n    }\n  }\n\n  return entries;\n};\n\nexport const flattenSort = (obj: Sort<any>[] = []): { sort?: string } => {\n  const flatten = (obj: Sort<any>, base = ''): string | undefined => {\n    const [key, value] = Object.entries(obj ?? {})[0] ?? [];\n\n    if (key && value) {\n      const path = base + key;\n\n      if (typeof value === 'object') {\n        return flatten(value, path ? `${path}.` : '');\n      } else if (['asc', 'desc'].includes(value)) {\n        return `${value === 'desc' ? '-' : ''}${path}`;\n      }\n    }\n\n    return undefined;\n  };\n\n  const sorts = obj.map((v) => flatten(v)).filter(Boolean);\n  return sorts.length ? { sort: sorts.join(',') } : {};\n};\n";
 
 const resolveImports = (target) => {
     const imports = [];
@@ -157,13 +157,13 @@ const resolveImports = (target) => {
 };
 const resolveMappings = (target) => `const wrapResponse = ${isRXTarget(target) ? 'defer' : '(v: (...args: any[]) => any) => v()'};`;
 const resolveBinaryClass = (target) => `const resolveBinaryObject = () => ${resolveBinaryType(target)};`;
-const generateBase = (target) => {
-    return generateStatements(resolveImports(target), resolveMappings(target), resolveBinaryClass(target), types, root);
+const generateBase = (apiVersion, { target, useQueryLanguage, generateUnique }) => {
+    return generateStatements(resolveImports(target), `const apiVersion = ${apiVersion}`, resolveMappings(target), resolveBinaryClass(target), globalConfig, types, utils, root, useQueryLanguage ? queriesWithQueryLanguage : queriesWithFilter, generateUnique ? unique : '', multiRequest);
 };
 
 const transformKey = (s) => snakeCase(s).toUpperCase();
 const generateEnum = (name, values) => {
-    const props = indent(values.map(v => `${transformKey(v)} = ${generateString(v)}`).join(',\n'));
+    const props = indent(values.map((v) => `${transformKey(v)} = ${generateString(v)}`).join(',\n'));
     return `export enum ${name} {\n${props}\n}`;
 };
 
@@ -191,22 +191,17 @@ const isArraySchemaObject = (v) => {
 const isResponseObject = (v) => {
     return isObject(v) && typeof v.description === 'string';
 };
-const isNonArraySchemaObject = (v) => {
-    return isObject(v) && ['string', 'undefined'].includes(typeof v.type);
-};
-const isRelatedEntitySchema = (v) => {
-    return isObject(v) && isNonArraySchemaObject(v) && 'x-weclapp' in v && isObject(v['x-weclapp']);
-};
 
-const generateEnums = (schemas) => {
+const generateEnums = (context) => {
     const enums = new Map();
-    for (const [propName, schema] of schemas) {
+    for (const [schemaName, schema] of context.schemas) {
         if (isEnumSchemaObject(schema)) {
-            const name = loosePascalCase(propName);
-            if (!enums.has(name)) {
-                enums.set(name, {
+            const enumName = loosePascalCase(schemaName);
+            if (!enums.has(enumName)) {
+                enums.set(enumName, {
+                    name: enumName,
                     properties: schema.enum,
-                    source: generateEnum(name, schema.enum)
+                    source: generateEnum(enumName, schema.enum)
                 });
             }
         }
@@ -218,16 +213,30 @@ const concat = (strings, separator = ', ', maxLength = 80) => {
     const joined = strings.join(separator);
     if (joined.length > maxLength) {
         const length = strings.length - 1;
-        return `\n${indent(strings
-            .map((value, index) => index === length ? value : `${(value + separator).trim()}\n`)
-            .join(''))}\n`;
+        return `\n${indent(strings.map((value, index) => (index === length ? value : `${(value + separator).trim()}\n`)).join(''))}\n`;
     }
     else {
         return joined;
     }
 };
 
-/* eslint-disable no-use-before-define */
+const convertParametersToSchemaObject = (parameters) => {
+    const properties = [];
+    const required = [];
+    for (const param of parameters) {
+        if (param.in === 'query' && param.schema) {
+            properties.push([param.name, param.schema]);
+            if (param.required)
+                required.push(param.name);
+        }
+    }
+    return {
+        type: 'object',
+        properties: Object.fromEntries(properties),
+        required
+    };
+};
+
 const createReferenceType = (value) => ({
     type: 'reference',
     toString: () => loosePascalCase(value)
@@ -242,22 +251,25 @@ const createArrayType = (value) => ({
 });
 const createTupleType = (value) => ({
     type: 'tuple',
-    toString: () => concat([...new Set(value.map(v => typeof v === 'string' ? `'${v}'` : v.toString()))], ' | ')
+    toString: () => concat([...new Set(value.map((v) => (typeof v === 'string' ? `'${v}'` : v.toString())))], ' | ')
 });
 const createObjectType = (value, required = []) => ({
     type: 'object',
     isFullyOptional: () => {
-        return !required.length && Object.values(value)
-            .filter(v => v?.type === 'object')
-            .every(v => v.isFullyOptional());
+        return (!required.length &&
+            Object.values(value)
+                .filter((v) => v?.type === 'object')
+                .every((v) => v.isFullyOptional()));
     },
-    toString: (propagateOptionalProperties = false) => {
+    toString: (propertyPropagationOption = 'ignore') => {
         const properties = Object.entries(value)
-            .filter(v => v[1])
-            .map(v => {
+            .filter((v) => v[1])
+            .map((v) => {
             const name = v[0];
             const value = v[1];
-            const isRequired = required.includes(name) || (value.type === 'object' && !value.isFullyOptional() && propagateOptionalProperties);
+            const isRequired = required.includes(name) ||
+                propertyPropagationOption === 'force' ||
+                (value.type === 'object' && !value.isFullyOptional() && propertyPropagationOption === 'propagate');
             return `${name + (isRequired ? '' : '?')}: ${value.toString()};`;
         });
         return properties.length ? `{\n${indent(properties.join('\n'))}\n}` : '{}';
@@ -266,8 +278,11 @@ const createObjectType = (value, required = []) => ({
 const getRefName = (obj) => {
     return obj.$ref.replace(/.*\//, '');
 };
-const convertToTypeScriptType = (schema, property) => {
-    if (isReferenceObject(schema)) {
+const convertToTypeScriptType = (schema) => {
+    if (Array.isArray(schema)) {
+        return convertToTypeScriptType(convertParametersToSchemaObject(schema));
+    }
+    else if (isReferenceObject(schema)) {
         return createReferenceType(getRefName(schema));
     }
     else {
@@ -277,7 +292,7 @@ const convertToTypeScriptType = (schema, property) => {
                 return createRawType('number');
             case 'string':
                 if (schema.enum) {
-                    return property ? createReferenceType(property) : createTupleType(schema.enum);
+                    return createTupleType(schema.enum);
                 }
                 else {
                     return schema.format === 'binary' ? createRawType('binary') : createRawType('string');
@@ -286,46 +301,53 @@ const convertToTypeScriptType = (schema, property) => {
                 return createRawType('boolean');
             case 'object': {
                 const { properties = {}, required = [] } = schema;
-                return createObjectType(Object.fromEntries(Object.entries(properties)
-                    .map(v => [v[0], convertToTypeScriptType(v[1])])), required);
+                return createObjectType(Object.fromEntries(Object.entries(properties).map(([prop, propSchema]) => [prop, convertToTypeScriptType(propSchema)])), required);
             }
             case 'array':
-                return createArrayType(convertToTypeScriptType(schema.items, property));
+                return createArrayType(convertToTypeScriptType(schema.items));
             default:
                 return createRawType('unknown');
         }
     }
 };
 
-const setEntityEnumProperty = (enums, prop, meta) => {
+const setReferenceMeta = (prop, metaData, context) => {
     const referenceName = getRefName(prop);
-    const enumName = loosePascalCase(referenceName);
-    if (enums.has(enumName)) {
-        meta.enum = enumName;
+    const referenceSchema = context.schemas.get(referenceName);
+    if (isEnumSchemaObject(referenceSchema)) {
+        metaData.enum = loosePascalCase(referenceName);
     }
     else {
-        meta.entity = referenceName;
+        metaData.entity = referenceName;
     }
 };
-const extractPropertyMetaData = (enums, meta, prop) => {
-    const result = { service: meta.service, entity: meta.entity };
+const extractPropertyMetaData = (prop, context) => {
+    const metaData = {};
+    const weclappExtension = prop['x-weclapp'];
+    if (weclappExtension) {
+        metaData.service = weclappExtension.service;
+        metaData.entity = weclappExtension.entity;
+    }
     if (isReferenceObject(prop)) {
-        setEntityEnumProperty(enums, prop, result);
-        result.type = 'reference';
-        return result;
-    }
-    result.format = prop.format;
-    result.type = prop.type;
-    if (isArraySchemaObject(prop)) {
-        if (isReferenceObject(prop.items)) {
-            setEntityEnumProperty(enums, prop.items, result);
-            result.format = 'reference';
-        }
-        else {
-            result.format = 'string';
+        metaData.type = 'reference';
+        setReferenceMeta(prop, metaData, context);
+    }
+    else {
+        metaData.type = prop.type;
+        metaData.format = prop.format;
+        metaData.maxLength = prop.maxLength;
+        metaData.pattern = prop.pattern;
+        if (isArraySchemaObject(prop)) {
+            if (isReferenceObject(prop.items)) {
+                metaData.format = 'reference';
+                setReferenceMeta(prop.items, metaData, context);
+            }
+            else {
+                metaData.format = 'string';
+            }
         }
     }
-    return result;
+    return metaData;
 };
 
 const generateInlineComment = (comment) => `/** ${comment} */`;
@@ -335,12 +357,12 @@ const generateType = (name, value) => {
     return `export type ${name} = ${value.trim()};`;
 };
 
-const arrayify = (v) => Array.isArray(v) ? v : [v];
+const arrayify = (v) => (Array.isArray(v) ? v : [v]);
 
 const generateInterfaceProperties = (entries) => {
     const properties = entries
-        .filter(v => v.type !== undefined)
-        .filter((value, index, array) => array.findIndex(v => v.name === value.name) === index)
+        .filter((v) => v.type !== undefined)
+        .filter((value, index, array) => array.findIndex((v) => v.name === value.name) === index)
         .map(({ name, type, required, readonly, comment }) => {
         const cmd = comment ? `${generateInlineComment(comment)}\n` : '';
         const req = required ? '' : '?';
@@ -350,7 +372,7 @@ const generateInterfaceProperties = (entries) => {
         .join('\n');
     return properties.length ? `{\n${indent(properties)}\n}` : `{}`;
 };
-const generateInterfaceFromObject = (name, obj, propagateOptionalProperties) => `export interface ${name} ${obj.toString(propagateOptionalProperties)}`;
+const generateInterfaceFromObject = (name, obj, propertyPropagationOption) => `export interface ${name} ${obj.toString(propertyPropagationOption)}`;
 const generateInterface = (name, entries, extend) => {
     const signature = `${name} ${extend ? `extends ${arrayify(extend).join(', ')}` : ''}`.trim();
     const body = generateInterfaceProperties(entries);
@@ -359,69 +381,17 @@ const generateInterface = (name, entries, extend) => {
 const generateInterfaceType = (name, entries, extend) => {
     const body = generateInterfaceProperties(entries);
     const bases = extend ? arrayify(extend).join(' & ') : undefined;
-    return generateType(name, `${bases ? `${bases} & ` : ''}${body}`);
-};
-
-const generateEntities = (schemas, enums) => {
-    const entities = new Map();
-    for (const [schemaName, schema] of schemas) {
-        // Enums are generated separately
-        if (isEnumSchemaObject(schema)) {
-            continue;
-        }
-        const entity = pascalCase(schemaName);
-        // Entity and filter
-        const entityInterface = [];
-        const filterInterface = [];
-        // Referenced entities and property-to-referenced-entity mapping
-        const referenceInterface = [];
-        const referenceMappingsInterface = [];
-        const properties = new Map();
-        // The parent entity
-        let extend = undefined;
-        const processProperties = (props = {}) => {
-            for (const [name, property] of Object.entries(props)) {
-                const meta = isRelatedEntitySchema(property) ? property['x-weclapp'] : {};
-                if (meta.entity) {
-                    const type = `${pascalCase(meta.entity)}[]`;
-                    referenceInterface.push({ name, type, required: true });
-                    filterInterface.push({ name: meta.entity, type, required: true });
-                }
-                if (meta.service) {
-                    referenceMappingsInterface.push({ name, type: generateString(meta.service), required: true });
-                }
-                const type = convertToTypeScriptType(property, name).toString();
-                const comment = isNonArraySchemaObject(property) ?
-                    property.deprecated ? '@deprecated will be removed.' :
-                        property.format ? `format: ${property.format}` :
-                            undefined : undefined;
-                entityInterface.push({
-                    name, type, comment,
-                    required: meta.required,
-                    readonly: !isReferenceObject(property) && property.readOnly
-                });
-                properties.set(name, extractPropertyMetaData(enums, meta, property));
-            }
-        };
-        if (schema.allOf?.length) {
-            for (const item of schema.allOf) {
-                if (isReferenceObject(item)) {
-                    extend = convertToTypeScriptType(item).toString();
-                }
-                else if (isObjectSchemaObject(item)) {
-                    processProperties(item.properties);
-                }
-            }
-        }
-        processProperties(schema.properties);
-        const source = generateStatements(generateInterface(entity, entityInterface, extend), generateInterface(`${entity}_References`, referenceInterface, extend ? [`${extend}_References`] : undefined), generateInterface(`${entity}_Mappings`, referenceMappingsInterface, extend ? [`${extend}_Mappings`] : undefined), generateInterfaceType(`${entity}_Filter`, filterInterface, extend ? [entity, `${extend}_Filter`] : undefined));
-        entities.set(schemaName, {
-            extends: extend ? camelCase(extend) : extend,
-            properties,
-            source
-        });
+    let typeDefinition = '';
+    if (bases) {
+        typeDefinition = bases;
     }
-    return entities;
+    else {
+        typeDefinition = body;
+    }
+    if (bases && body !== '{}') {
+        typeDefinition += ` & ${body}`;
+    }
+    return generateType(name, typeDefinition);
 };
 
 /**
@@ -429,13 +399,10 @@ const generateEntities = (schemas, enums) => {
  * @param s String to pluralize.
  */
 const pluralize = (s) => {
-    return s.endsWith('s') ? s :
-        s.endsWith('y') ? `${s.slice(0, -1)}ies` :
-            `${s}s`;
+    return s.endsWith('s') ? s : s.endsWith('y') ? `${s.slice(0, -1)}ies` : `${s}s`;
 };
 
-/* eslint-disable no-console */
-const logger = new class {
+const logger = new (class {
     active = true;
     warnings = 0;
     errors = 0;
@@ -483,21 +450,126 @@ const logger = new class {
     printSummary() {
         const format = (v, name, fail, ok) => {
             const color = v ? fail : ok;
-            return v === 0 ? `${color('zero')} ${pluralize(name)}` :
-                v === 1 ? `${color('one')} ${name}` : `${color(v)} ${pluralize(name)}`;
+            return v === 0
+                ? `${color('zero')} ${pluralize(name)}`
+                : v === 1
+                    ? `${color('one')} ${name}`
+                    : `${color(v)} ${pluralize(name)}`;
         };
         const warnings = format(this.warnings, 'warning', chalk.yellowBright, chalk.greenBright);
         const errors = format(this.errors, 'error', chalk.redBright, chalk.greenBright);
         const info = `Finished with ${warnings} and ${errors}.`;
         this[this.errors ? 'errorLn' : this.warnings ? 'warnLn' : 'successLn'](info);
     }
+})();
+
+const FILTER_PROPS_SUFFIX = 'Filter_Props';
+const generateEntities = (context) => {
+    const entities = new Map();
+    for (const [schemaName, schema] of context.schemas) {
+        // Enums are generated separately
+        if (isEnumSchemaObject(schema)) {
+            continue;
+        }
+        const entityName = schemaName;
+        const entityInterfaceName = loosePascalCase(entityName);
+        const entityInterfaceProperties = [];
+        const properties = new Map();
+        let parentEntityName = undefined;
+        let parentEntityInterfaceName = undefined;
+        const entityFilterInterfaceName = `${entityInterfaceName}_${FILTER_PROPS_SUFFIX}`;
+        const entityFilterInterfaceProperties = [];
+        let parentEntityFilterInterfaceName = undefined;
+        const processProperties = (props = {}) => {
+            for (const [propertyName, propertySchema] of Object.entries(props)) {
+                const weclappExtension = propertySchema['x-weclapp'];
+                properties.set(propertyName, extractPropertyMetaData(propertySchema, context));
+                const type = convertToTypeScriptType(propertySchema).toString();
+                // cast to SchemaObject to access deprecated and readOnly properties (ReferenceObject can also include these props in OpenAPI 3.1)
+                const castedSchema = propertySchema;
+                const comment = castedSchema.deprecated
+                    ? '@deprecated will be removed.'
+                    : castedSchema.format
+                        ? `format: ${castedSchema.format}`
+                        : undefined;
+                if (weclappExtension?.filterable !== false) {
+                    entityFilterInterfaceProperties.push({ name: propertyName, type, comment });
+                }
+                entityInterfaceProperties.push({
+                    name: propertyName,
+                    type,
+                    required: weclappExtension?.required,
+                    readonly: castedSchema.readOnly,
+                    comment
+                });
+            }
+        };
+        const processExtraFilterProperties = (props = {}) => {
+            for (const [propertyName, propertySchema] of Object.entries(props)) {
+                if (isReferenceObject(propertySchema))
+                    continue;
+                const type = convertToTypeScriptType(propertySchema).toString();
+                const comment = propertySchema.deprecated
+                    ? '@deprecated will be removed.'
+                    : propertySchema.format
+                        ? `format: ${propertySchema.format}`
+                        : undefined;
+                entityFilterInterfaceProperties.push({ name: propertyName, type, comment });
+            }
+        };
+        const processFilterPaths = (filterPaths = {}) => {
+            for (const [filterProp, entityName] of Object.entries(filterPaths)) {
+                if (!filterProp.includes('.') && context.schemas.get(entityName)) {
+                    entityFilterInterfaceProperties.push({
+                        name: filterProp,
+                        type: `${loosePascalCase(entityName)}_${FILTER_PROPS_SUFFIX}`
+                    });
+                }
+            }
+        };
+        if (schema.allOf?.length) {
+            if (schema.allOf.length > 2) {
+                logger.errorLn(`Failed to process schema for ${schemaName}: invalid allOf length`);
+                continue;
+            }
+            for (const item of schema.allOf) {
+                if (isReferenceObject(item)) {
+                    parentEntityName = getRefName(item);
+                    parentEntityInterfaceName = createReferenceType(parentEntityName).toString();
+                    parentEntityFilterInterfaceName = `${parentEntityInterfaceName}_${FILTER_PROPS_SUFFIX}`;
+                }
+                else if (item.type === 'object') {
+                    processProperties(item.properties);
+                    processExtraFilterProperties(item['x-weclapp-filterProperties']);
+                    processFilterPaths(item['x-weclapp-filterPaths']);
+                }
+                else {
+                    logger.errorLn(`Failed to process schema for ${schemaName}: invalid schema type in allOf`);
+                }
+            }
+        }
+        else {
+            processProperties(schema.properties);
+        }
+        entities.set(entityName, {
+            name: entityName,
+            interfaceName: entityInterfaceName,
+            properties,
+            source: generateStatements(generateInterface(entityInterfaceName, entityInterfaceProperties, parentEntityInterfaceName)),
+            filterInterfaceName: entityFilterInterfaceName,
+            filterSource: generateStatements(generateInterface(entityFilterInterfaceName, entityFilterInterfaceProperties, parentEntityFilterInterfaceName)),
+            parentName: parentEntityName,
+            parentInterfaceName: parentEntityInterfaceName
+        });
+    }
+    return entities;
 };
 
 /**
- * ROOT           => /article
- * COUNT          => /article/count
- * ENTITY         => /article/{id}
- * SPECIAL_ROOT   => /article/generateImage
+ * ROOT => /article
+ * COUNT => /article/count
+ * ENTITY => /article/{id}
+ * SPECIAL_ROOT => /article/generateImage
  * SPECIAL_ENTITY => /article/id/{id}/generateImag
  */
 var WeclappEndpointType;
@@ -509,26 +581,61 @@ var WeclappEndpointType;
     WeclappEndpointType["GENERIC_ENTITY"] = "GENERIC_ENTITY";
 })(WeclappEndpointType || (WeclappEndpointType = {}));
 const parseEndpointPath = (path) => {
-    const [, entity, ...rest] = path.split('/');
-    if (!entity) {
+    const [, service, ...rest] = path.split('/');
+    if (!service) {
         return undefined;
     }
     if (!rest.length) {
-        return { path, entity, type: WeclappEndpointType.ROOT };
+        return { path, service, type: WeclappEndpointType.ROOT };
     }
     else if (rest[0] === 'count') {
-        return { path, entity, type: WeclappEndpointType.COUNT };
+        return { path, service, type: WeclappEndpointType.COUNT };
     }
     else if (rest[0] === 'id') {
-        return rest.length === 2 ?
-            { path, entity, type: WeclappEndpointType.ENTITY } :
-            { path, entity, method: rest[2], type: WeclappEndpointType.GENERIC_ENTITY };
+        return rest.length === 2
+            ? { path, service, type: WeclappEndpointType.ENTITY }
+            : {
+                path,
+                service,
+                method: rest[2],
+                type: WeclappEndpointType.GENERIC_ENTITY
+            };
     }
     else if (rest.length === 1) {
-        return { path, entity, method: rest[1], type: WeclappEndpointType.GENERIC_ROOT };
+        return {
+            path,
+            service,
+            method: rest[1],
+            type: WeclappEndpointType.GENERIC_ROOT
+        };
     }
     return undefined;
 };
+const isMultiPartUploadPath = (path) => {
+    const [, entity, ...rest] = path.split('/');
+    return entity && rest.length === 2 && rest[1] === 'multipartUpload';
+};
+const parseEndpointsPaths = (paths) => {
+    const endpoints = new Map();
+    for (const [rawPath, path] of Object.entries(paths)) {
+        const endpoint = parseEndpointPath(rawPath);
+        if (!endpoint || !path) {
+            // Todo: Should be removed if sdk supports multi part upload.
+            if (isMultiPartUploadPath(rawPath)) {
+                continue;
+            }
+            logger.errorLn(`Failed to parse ${rawPath}`);
+            continue;
+        }
+        if (endpoints.has(endpoint.service)) {
+            endpoints.get(endpoint.service)?.push({ endpoint, path });
+        }
+        else {
+            endpoints.set(endpoint.service, [{ endpoint, path }]);
+        }
+    }
+    return endpoints;
+};
 
 const generateArrowFunction = ({ name, signature, returns, params }) => {
     return `const ${name}: ${signature} = (${params?.join(', ') ?? ''}) =>\n${indent(returns)};`;
@@ -540,109 +647,109 @@ const generateArrowFunctionType = ({ type, returns = 'void', generics, params })
     return generateType(type, `${genericsString + paramsString} =>\n${indent(returns)}`);
 };
 
-const convertParametersToSchema = (parameters = []) => {
-    const properties = [];
-    const required = [];
-    for (const param of parameters) {
-        if (isParameterObject(param) && param.in === 'query') {
-            if (param.schema) {
-                properties.push([param.name, param.schema]);
-                param.required && required.push(param.name);
-            }
+const resolveParameters = (resolvableParameters = [], parameters) => {
+    if (!resolvableParameters)
+        return [];
+    return resolvableParameters.flatMap((param) => {
+        if (isReferenceObject(param)) {
+            const resolved = parameters.get(getRefName(param));
+            return resolved ? [resolved] : [];
         }
-    }
-    return {
-        type: 'object', required,
-        properties: Object.fromEntries(properties)
-    };
+        return [param];
+    });
 };
 
-const functionName$5 = 'count';
-const generateCountEndpoint = ({ aliases, path, target, endpoint }) => {
-    const service = pascalCase(endpoint.entity);
-    const entity = aliases.get(endpoint.entity) ?? service;
-    const entityFilter = `${entity}_Filter`;
-    const interfaceName = `${service}Service_${pascalCase(functionName$5)}`;
-    const entityParameters = `${interfaceName}_Parameters`;
-    const parameterSchema = convertParametersToSchema(path.parameters);
-    const parameters = createObjectType({
-        params: convertToTypeScriptType(parameterSchema)
+const generateCountEndpoint = ({ endpoint, operationObject, entities, context, options }) => {
+    const functionName = 'count';
+    const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
+    const relatedEntityName = context.aliases.get(endpoint.service);
+    const relatedEntity = !!relatedEntityName && entities.get(relatedEntityName);
+    if (!relatedEntity) {
+        throw Error(`Related entity schema for service ${endpoint.service} not found`);
+    }
+    const parametersTypeName = `${functionTypeName}_Parameters`;
+    const parametersType = createObjectType({
+        params: convertToTypeScriptType(resolveParameters(operationObject.parameters, context.parameters))
     });
-    const functionSource = generateArrowFunction({
-        name: functionName$5,
-        signature: interfaceName,
-        returns: `_${functionName$5}(cfg, ${generateString(endpoint.path)}, query)`,
-        params: ['query']
+    const parametersTypeSource = generateInterfaceFromObject(parametersTypeName, parametersType, 'propagate');
+    const filterTypeName = `${functionTypeName}_Filter`;
+    const filterTypeSource = generateInterfaceType(filterTypeName, [], [`${relatedEntity.filterInterfaceName}`]);
+    const functionTypeSource = generateArrowFunctionType({
+        type: functionTypeName,
+        params: [
+            `query${parametersType.isFullyOptional() ? '?' : ''}: CountQuery<${filterTypeName}>${operationObject.parameters?.length ? ' & ' + parametersTypeName : ''}`,
+            'requestOptions?: RequestOptions'
+        ],
+        returns: `${resolveResponseType(options.target)}<number>`
     });
-    const interfaceSource = generateArrowFunctionType({
-        type: interfaceName,
-        params: [`query${parameters.isFullyOptional() ? '?' : ''}: CountQuery<${entityFilter}> & ${entityParameters}`],
-        returns: `${resolveResponseType(target)}<number>`
+    const functionSource = generateArrowFunction({
+        name: functionName,
+        signature: functionTypeName,
+        returns: `_${functionName}(cfg, ${generateString(endpoint.path)}, query, requestOptions)`,
+        params: ['query', 'requestOptions?: RequestOptions']
     });
     return {
-        entity,
-        name: functionName$5,
-        type: { name: interfaceName, source: interfaceSource },
-        func: { name: functionName$5, source: functionSource },
+        name: functionName,
+        type: { name: functionTypeName, source: functionTypeSource },
+        func: { name: functionName, source: functionSource },
         interfaces: [
-            {
-                name: entityParameters,
-                source: generateInterfaceFromObject(entityParameters, parameters, true)
-            }
+            ...(operationObject.parameters?.length ? [{ name: parametersTypeName, source: parametersTypeSource }] : []),
+            { name: filterTypeName, source: filterTypeSource }
         ]
     };
 };
 
-const generateBodyType = (body) => {
-    if (isReferenceObject(body)) {
-        return convertToTypeScriptType(body);
-    }
+const generateContentType = (body, fallback = 'unknown') => {
+    if (!body?.content)
+        return createRawType(fallback);
     const types = [];
-    for (const { schema } of Object.values(body?.content ?? {})) {
+    for (const { schema } of Object.values(body.content)) {
         if (schema) {
             types.push(convertToTypeScriptType(schema));
         }
     }
-    return types.length ? createTupleType(types) : undefined;
+    return (types.length > 1 ? createTupleType(types) : types[0]) ?? createRawType(fallback);
 };
 
-const generateRequestBodyType = ({ requestBody }) => {
-    return generateBodyType(requestBody) ?? createRawType('unknown');
+const generateRequestBodyType = ({ requestBody }, requestBodies) => {
+    const requestBodyObject = requestBody && isReferenceObject(requestBody) ? requestBodies.get(getRefName(requestBody)) : requestBody;
+    return generateContentType(requestBodyObject);
 };
 
-const resolveBodyType = ({ responses }) => Object.entries(responses)
-    .filter(v => v[0].startsWith('2'))[0]?.[1];
-const generateResponseBodyType = (object) => generateBodyType(resolveBodyType(object)) ?? createRawType('void');
+const resolveResponsesObject = (responses) => Object.entries(responses).find(([statusCode]) => statusCode.startsWith('2'))?.[1];
 
-const functionName$4 = 'create';
-const generateCreateEndpoint = ({ target, path, endpoint }) => {
-    const entity = pascalCase(endpoint.entity);
-    const interfaceName = `${entity}Service_${pascalCase(functionName$4)}`;
-    const functionSource = generateArrowFunction({
-        name: functionName$4,
-        signature: interfaceName,
-        returns: `_${functionName$4}(cfg, ${generateString(endpoint.path)}, data)`,
-        params: ['data']
+const generateResponseType = (operationObject, responses) => {
+    const response = resolveResponsesObject(operationObject.responses);
+    const responseObject = response && isReferenceObject(response) ? responses.get(getRefName(response)) : response;
+    return generateContentType(responseObject, 'void');
+};
+
+const generateCreateEndpoint = ({ endpoint, operationObject, context, options }) => {
+    const functionName = 'create';
+    const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
+    const functionTypeSource = generateArrowFunctionType({
+        type: functionTypeName,
+        params: [
+            `data: DeepPartial<${generateRequestBodyType(operationObject, context.requestBodies).toString()}>`,
+            'requestOptions?: RequestOptions'
+        ],
+        returns: `${resolveResponseType(options.target)}<${generateResponseType(operationObject, context.responses).toString()}>`
     });
-    const interfaceSource = generateArrowFunctionType({
-        type: interfaceName,
-        params: [`data: DeepPartial<${generateRequestBodyType(path).toString()}>`],
-        returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
+    const functionSource = generateArrowFunction({
+        name: functionName,
+        signature: functionTypeName,
+        returns: `_${functionName}(cfg, ${generateString(endpoint.path)}, data, requestOptions)`,
+        params: ['data', 'requestOptions?: RequestOptions']
     });
     return {
-        entity,
-        name: functionName$4,
-        type: { name: interfaceName, source: interfaceSource },
-        func: { name: functionName$4, source: functionSource }
+        name: functionName,
+        type: { name: functionTypeName, source: functionTypeSource },
+        func: { name: functionName, source: functionSource }
     };
 };
 
 const generateGenericFunctionName = (path, suffix = '', prefix = '') => {
-    return camelCase(`${prefix}_` +
-        path
-            .replace(/.*\//, '')
-            .replace(/\W+/, '_')
-            .replace(/[_]+/, '_') + `_${suffix}`);
+    return camelCase(`${prefix}_` + path.replace(/.*\//, '').replace(/\W+/, '_').replace(/[_]+/, '_') + `_${suffix}`);
 };
 
 const insertPathPlaceholder = (path, record) => {
@@ -650,77 +757,81 @@ const insertPathPlaceholder = (path, record) => {
 };
 
 const wrapBody = (type, target) => {
-    return type.toString() === 'binary' ?
-        createRawType(isNodeTarget(target) ? 'BodyInit' : 'Blob') :
-        type; // node-fetch returns a Blob as well
+    return type.toString() === 'binary' ? createRawType(isNodeTarget(target) ? 'BodyInit' : 'Blob') : type; // node-fetch returns a Blob as well
 };
-const generateGenericEndpoint = (suffix) => ({ target, method, path, endpoint }) => {
+const generateGenericEndpoint = (suffix) => ({ method, endpoint, operationObject, context, options }) => {
     const functionName = generateGenericFunctionName(endpoint.path, suffix, method);
-    const entity = pascalCase(endpoint.entity);
-    const interfaceName = `${entity}Service_${pascalCase(functionName)}`;
-    const entityQuery = `${interfaceName}_Query`;
+    const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
+    const entityQuery = `${functionTypeName}_Query`;
     const hasId = endpoint.path.includes('{id}');
     const params = createObjectType({
-        params: convertToTypeScriptType(convertParametersToSchema(path.parameters)),
-        body: method === 'get' ? undefined : wrapBody(generateRequestBodyType(path), target)
+        params: operationObject.parameters &&
+            convertToTypeScriptType(resolveParameters(operationObject.parameters, context.parameters)),
+        body: method === 'get'
+            ? undefined
+            : wrapBody(generateRequestBodyType(operationObject, context.requestBodies), options.target)
+    });
+    const responseBody = generateResponseType(operationObject, context.responses);
+    const functionTypeSource = generateArrowFunctionType({
+        type: functionTypeName,
+        params: [
+            ...(hasId ? ['id: string'] : []),
+            `query${params.isFullyOptional() ? '?' : ''}: ${entityQuery}`,
+            'requestOptions?: RequestOptions'
+        ],
+        returns: `${resolveResponseType(options.target)}<${wrapBody(responseBody, options.target).toString('force')}>`
     });
-    const responseBody = generateResponseBodyType(path);
-    const forceBlobResponse = String(responseBody.toString() === 'binary');
     const functionSource = generateArrowFunction({
         name: functionName,
-        signature: interfaceName,
-        params: hasId ? ['id', 'query'] : ['query'],
-        returns: `_generic(cfg, ${generateString(method.toUpperCase())}, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, query, ${forceBlobResponse})`
-    });
-    const interfaceSource = generateArrowFunctionType({
-        type: interfaceName,
-        params: [...(hasId ? ['id: string'] : []), `query${params.isFullyOptional() ? '?' : ''}: ${entityQuery}`],
-        returns: `${resolveResponseType(target)}<${wrapBody(responseBody, target).toString()}>`
+        signature: functionTypeName,
+        params: hasId ? ['id', 'query', 'requestOptions?: RequestOptions'] : ['query', 'requestOptions?: RequestOptions'],
+        returns: `_generic(cfg, ${generateString(method.toUpperCase())}, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, query, ${String(responseBody.toString() === 'binary')}, requestOptions)`
     });
     return {
-        entity,
         name: functionName,
-        type: { name: interfaceName, source: interfaceSource },
+        type: { name: functionTypeName, source: functionTypeSource },
         func: { name: functionName, source: functionSource },
         interfaces: [
             {
                 name: entityQuery,
-                source: generateInterfaceFromObject(entityQuery, params, true)
+                source: generateInterfaceFromObject(entityQuery, params, 'propagate')
             }
         ]
     };
 };
 
-const functionName$3 = 'remove';
-const generateRemoveEndpoint = ({ target, endpoint }) => {
-    const entity = pascalCase(endpoint.entity);
-    const interfaceName = `${entity}Service_${pascalCase(functionName$3)}`;
-    const functionSource = generateArrowFunction({
-        name: functionName$3,
-        signature: interfaceName,
-        returns: `_${functionName$3}(cfg, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, options)`,
-        params: ['id', 'options?: RemoveQuery']
+const generateRemoveEndpoint = ({ endpoint, options }) => {
+    const functionName = 'remove';
+    const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
+    const functionTypeSource = generateArrowFunctionType({
+        type: functionTypeName,
+        params: ['id: string', 'options?: RemoveQuery', 'requestOptions?: RequestOptions'],
+        returns: `${resolveResponseType(options.target)}<void>`
     });
-    const interfaceSource = generateArrowFunctionType({
-        type: interfaceName,
-        params: ['id: string', 'options?: RemoveQuery'],
-        returns: `${resolveResponseType(target)}<void>`
+    const functionSource = generateArrowFunction({
+        name: functionName,
+        signature: functionTypeName,
+        returns: `_${functionName}(cfg, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, options, requestOptions)`,
+        params: ['id', 'options?: RemoveQuery', 'requestOptions?: RequestOptions']
     });
     return {
-        entity,
-        name: functionName$3,
-        type: { name: interfaceName, source: interfaceSource },
-        func: { name: functionName$3, source: functionSource }
+        name: functionName,
+        type: { name: functionTypeName, source: functionTypeSource },
+        func: { name: functionName, source: functionSource }
     };
 };
 
-const functionName$2 = 'some';
 const excludedParameters = [
-    'page', 'pageSize', 'sort',
-    'serializeNulls', 'properties', 'includeReferencedEntities'
+    'page',
+    'pageSize',
+    'sort',
+    'serializeNulls',
+    'properties',
+    'includeReferencedEntities',
+    'additionalProperties'
 ];
-const resolveAdditionalProperties = (path) => {
-    const body = resolveBodyType(path);
+const resolveAdditionalPropertiesSchema = ({ responses }) => {
+    const body = resolveResponsesObject(responses);
     if (isResponseObject(body)) {
         const schema = body?.content?.['application/json']?.schema;
         if (isObjectSchemaObject(schema)) {
@@ -732,276 +843,311 @@ const resolveAdditionalProperties = (path) => {
     }
     return undefined;
 };
-const generateSomeEndpoint = ({ aliases, target, path, endpoint }) => {
-    // Required interface names
-    const service = pascalCase(endpoint.entity);
-    const entity = aliases.get(endpoint.entity) ?? service;
-    const interfaceName = `${service}Service_${pascalCase(functionName$2)}`;
-    const entityFilter = `${entity}_Filter`;
-    const entityMappings = `${entity}_Mappings`;
-    const entityReferences = `${entity}_References`;
-    const entityParameters = `${service}_Parameters`;
-    const parameterSchema = convertParametersToSchema(path.parameters);
-    const additionalProperties = resolveAdditionalProperties(path);
-    const additionalPropertyNames = generateStrings(Object.keys(additionalProperties?.properties ?? {}));
-    const additionalPropertyNamesType = additionalPropertyNames.length ? `(${concat(additionalPropertyNames, ' | ')})[]` : '[]';
-    // We already cover some properties
-    parameterSchema.properties = Object.fromEntries(Object.entries(parameterSchema.properties ?? {})
-        .filter(v => !excludedParameters.includes(v[0])));
-    const parameters = createObjectType({
-        params: convertToTypeScriptType(parameterSchema)
+const resolveReferences = (entity, entities) => {
+    const references = [];
+    const generatedEntity = entities.get(entity);
+    if (generatedEntity) {
+        for (const [property, propertyMetaData] of generatedEntity.properties) {
+            if (propertyMetaData.service) {
+                references.push({
+                    name: property,
+                    type: generateString(propertyMetaData.service),
+                    required: true
+                });
+            }
+        }
+        if (generatedEntity.parentName) {
+            references.push(...resolveReferences(generatedEntity.parentName, entities));
+        }
+    }
+    return references;
+};
+const resolveReferencedEntities = (entity, entities) => {
+    const referencedEntities = [];
+    const generatedEntity = entities.get(entity);
+    if (generatedEntity) {
+        for (const [, propertyMetaData] of generatedEntity.properties) {
+            if (propertyMetaData.service && propertyMetaData.entity) {
+                const referencedEntity = entities.get(propertyMetaData.entity);
+                if (referencedEntity)
+                    referencedEntities.push({
+                        name: propertyMetaData.service,
+                        type: `${referencedEntity.interfaceName}[]`,
+                        required: true
+                    });
+            }
+        }
+        if (generatedEntity.parentName) {
+            referencedEntities.push(...resolveReferencedEntities(generatedEntity.parentName, entities));
+        }
+    }
+    return referencedEntities;
+};
+const generateSomeEndpoint = ({ endpoint, operationObject, entities, context, options }) => {
+    const functionName = 'some';
+    const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
+    const relatedEntityName = context.aliases.get(endpoint.service);
+    const relatedEntity = !!relatedEntityName && entities.get(relatedEntityName);
+    if (!relatedEntity) {
+        throw Error(`Related entity schema for service ${endpoint.service} not found`);
+    }
+    const parametersTypeName = `${functionTypeName}_Parameters`;
+    const parameters = operationObject.parameters?.filter((v) => isParameterObject(v) ? !excludedParameters.includes(v.name) : false);
+    const parametersType = createObjectType({
+        params: parameters && convertToTypeScriptType(resolveParameters(parameters, context.parameters))
     });
-    const properties = additionalProperties ? convertToTypeScriptType(additionalProperties).toString() : '{}';
-    const interfaceSource = generateArrowFunctionType({
-        type: interfaceName,
-        generics: [
-            `S extends (QuerySelect<${entity}> | undefined) = undefined`,
-            `I extends (QuerySelect<${entityMappings}> | undefined) = undefined`
-        ],
-        params: [`query${parameters.isFullyOptional() ? '?' : ''}: SomeQuery<${entity}, ${entityFilter}, I, S, ${additionalPropertyNamesType}> & ${entityParameters}`],
-        returns: `${resolveResponseType(target)}<SomeQueryReturn<${entity}, ${entityReferences}, ${entityMappings}, I, S, ${properties}>>`
+    const parametersTypeSource = generateInterfaceFromObject(parametersTypeName, parametersType, 'propagate');
+    const filterTypeName = `${functionTypeName}_Filter`;
+    const filterTypeSource = generateInterfaceType(filterTypeName, [], [`${relatedEntity.filterInterfaceName}`]);
+    const referencesTypeName = `${functionTypeName}_References`;
+    const referencesTypeSource = generateInterfaceType(referencesTypeName, resolveReferences(endpoint.service, entities));
+    const additionalPropertyTypeName = `${functionTypeName}_AdditionalProperty`;
+    const additionalPropertyTypeSource = generateType(additionalPropertyTypeName, 'string');
+    const queryTypeName = `${functionTypeName}_Query`;
+    const queryTypeSource = generateType(queryTypeName, `SomeQuery<${relatedEntity.interfaceName}, ${filterTypeName}, ${referencesTypeName}, ${additionalPropertyTypeName}> & ${parametersTypeName}`);
+    const referencedEntitiesTypeName = `${functionTypeName}_ReferencedEntities`;
+    const referencedEntitiesTypeSource = generateInterfaceType(referencedEntitiesTypeName, resolveReferencedEntities(endpoint.service, entities));
+    const additionalPropertiesTypeName = `${functionTypeName}_AdditionalProperties`;
+    const additionalPropertiesSchema = resolveAdditionalPropertiesSchema(operationObject);
+    const additionalPropertiesTypeSource = generateType(additionalPropertiesTypeName, additionalPropertiesSchema ? convertToTypeScriptType(additionalPropertiesSchema).toString() : '{}');
+    const functionTypeSource = generateArrowFunctionType({
+        type: functionTypeName,
+        params: [`query${parametersType.isFullyOptional() ? '?' : ''}: ${queryTypeName}, requestOptions?: RequestOptions`],
+        returns: `${resolveResponseType(options.target)}<SomeQueryReturn<${relatedEntity.interfaceName}, ${referencedEntitiesTypeName}, ${additionalPropertiesTypeName}>>`
     });
     const functionSource = generateArrowFunction({
-        name: functionName$2,
-        signature: interfaceName,
-        returns: `_${functionName$2}(cfg, ${generateString(endpoint.path)}, query)`,
-        params: ['query']
+        name: functionName,
+        signature: functionTypeName,
+        returns: `_${functionName}(cfg, ${generateString(endpoint.path)}, query, requestOptions)`,
+        params: ['query', 'requestOptions?: RequestOptions']
     });
     return {
-        entity,
-        name: functionName$2,
-        type: { name: interfaceName, source: interfaceSource },
-        func: { name: functionName$2, source: functionSource },
+        name: functionName,
+        type: { name: functionTypeName, source: functionTypeSource },
+        func: { name: functionName, source: functionSource },
         interfaces: [
-            {
-                name: entityParameters,
-                source: generateInterfaceFromObject(entityParameters, parameters, true)
-            }
+            { name: parametersTypeName, source: parametersTypeSource },
+            { name: filterTypeName, source: filterTypeSource },
+            { name: referencesTypeName, source: referencesTypeSource },
+            { name: additionalPropertyTypeName, source: additionalPropertyTypeSource },
+            { name: queryTypeName, source: queryTypeSource },
+            { name: referencedEntitiesTypeName, source: referencedEntitiesTypeSource },
+            { name: additionalPropertiesTypeName, source: additionalPropertiesTypeSource }
         ]
     };
 };
 
-const functionName$1 = 'unique';
-const generateUniqueEndpoint = ({ target, path, endpoint }) => {
-    const entity = pascalCase(endpoint.entity);
-    const interfaceName = `${entity}Service_${pascalCase(functionName$1)}`;
-    const functionSource = generateArrowFunction({
-        name: functionName$1,
-        signature: interfaceName,
-        params: ['id', 'query'],
-        returns: `_${functionName$1}(cfg, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, query)`
-    });
-    const interfaceSource = generateArrowFunctionType({
-        type: interfaceName,
-        params: ['id: string', 'query?: Q'],
+const generateUniqueEndpoint = ({ operationObject, endpoint, context, options }) => {
+    const functionName = 'unique';
+    const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
+    const functionTypeSource = generateArrowFunctionType({
+        type: functionTypeName,
+        params: ['id: string', 'query?: Q', 'requestOptions?: RequestOptions'],
         generics: ['Q extends UniqueQuery'],
-        returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
+        returns: `${resolveResponseType(options.target)}<${generateResponseType(operationObject, context.responses).toString()}>`
+    });
+    const functionSource = generateArrowFunction({
+        name: functionName,
+        signature: functionTypeName,
+        params: ['id', 'query', 'requestOptions?: RequestOptions'],
+        returns: `_${functionName}(cfg, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, query, requestOptions)`
     });
     return {
-        entity,
-        name: functionName$1,
-        type: { name: interfaceName, source: interfaceSource },
-        func: { name: functionName$1, source: functionSource }
+        name: functionName,
+        type: { name: functionTypeName, source: functionTypeSource },
+        func: { name: functionName, source: functionSource }
     };
 };
 
-const functionName = 'update';
-const generateUpdateEndpoint = ({ target, path, endpoint }) => {
-    const entity = pascalCase(endpoint.entity);
-    const interfaceName = `${entity}Service_${pascalCase(functionName)}`;
-    const interfaceSource = generateArrowFunctionType({
-        type: interfaceName,
-        params: ['id: string', `data: DeepPartial<${generateRequestBodyType(path).toString()}>`, 'options?: UpdateQuery'],
-        returns: `${resolveResponseType(target)}<${generateResponseBodyType(path).toString()}>`
+const generateUpdateEndpoint = ({ endpoint, operationObject, context, options }) => {
+    const functionName = 'update';
+    const functionTypeName = `${pascalCase(endpoint.service)}Service_${pascalCase(functionName)}`;
+    const functionTypeSource = generateArrowFunctionType({
+        type: functionTypeName,
+        params: [
+            'id: string',
+            `data: DeepPartial<${generateRequestBodyType(operationObject, context.requestBodies).toString()}>`,
+            'options?: UpdateQuery',
+            'requestOptions?: RequestOptions'
+        ],
+        returns: `${resolveResponseType(options.target)}<${generateResponseType(operationObject, context.responses).toString()}>`
     });
     const functionSource = generateArrowFunction({
         name: functionName,
-        signature: interfaceName,
-        returns: `_${functionName}(cfg, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, data, options)`,
-        params: ['id', 'data', 'options']
+        signature: functionTypeName,
+        returns: `_${functionName}(cfg, \`${insertPathPlaceholder(endpoint.path, { id: '${id}' })}\`, data, options, requestOptions)`,
+        params: ['id', 'data', 'options', 'requestOptions?: RequestOptions']
     });
     return {
-        entity,
         name: functionName,
-        type: { name: interfaceName, source: interfaceSource },
+        type: { name: functionTypeName, source: functionTypeSource },
         func: { name: functionName, source: functionSource }
     };
 };
 
-const groupEndpointsByEntity = (paths) => {
-    const endpoints = new Map();
-    for (const [rawPath, path] of Object.entries(paths)) {
-        const endpoint = parseEndpointPath(rawPath);
-        if (!endpoint || !path) {
-            logger.errorLn(`Failed to parse ${rawPath}`);
-            continue;
-        }
-        if (endpoints.has(endpoint.entity)) {
-            endpoints.get(endpoint.entity)?.push({ endpoint, path });
-        }
-        else {
-            endpoints.set(endpoint.entity, [{ endpoint, path }]);
-        }
-    }
-    return endpoints;
-};
-
 const generators = {
     /* /article */
     [WeclappEndpointType.ROOT]: {
-        get: generateSomeEndpoint,
-        post: generateCreateEndpoint
+        [OpenAPIV3.HttpMethods.GET]: generateSomeEndpoint,
+        [OpenAPIV3.HttpMethods.POST]: generateCreateEndpoint
     },
     /* /article/count */
     [WeclappEndpointType.COUNT]: {
-        get: generateCountEndpoint
+        [OpenAPIV3.HttpMethods.GET]: generateCountEndpoint
     },
     /* /article/:id */
     [WeclappEndpointType.ENTITY]: {
-        get: generateUniqueEndpoint,
-        delete: generateRemoveEndpoint,
-        put: generateUpdateEndpoint
+        [OpenAPIV3.HttpMethods.GET]: generateUniqueEndpoint,
+        [OpenAPIV3.HttpMethods.PUT]: generateUpdateEndpoint,
+        [OpenAPIV3.HttpMethods.DELETE]: generateRemoveEndpoint
     },
     /* /article/:id/method */
     [WeclappEndpointType.GENERIC_ENTITY]: {
-        get: generateGenericEndpoint('ById'),
-        post: generateGenericEndpoint('ById')
+        [OpenAPIV3.HttpMethods.GET]: generateGenericEndpoint('ById'),
+        [OpenAPIV3.HttpMethods.POST]: generateGenericEndpoint('ById')
     },
     /* /article/method */
     [WeclappEndpointType.GENERIC_ROOT]: {
-        get: generateGenericEndpoint(),
-        post: generateGenericEndpoint()
+        [OpenAPIV3.HttpMethods.GET]: generateGenericEndpoint(),
+        [OpenAPIV3.HttpMethods.POST]: generateGenericEndpoint()
     }
 };
-const generateServices = (doc, aliases, options) => {
+const generateServices = (entities, context, options) => {
     const services = new Map();
-    const grouped = groupEndpointsByEntity(doc.paths);
-    for (const [endpoint, paths] of grouped) {
-        const serviceName = camelCase(`${endpoint}Service`);
-        const serviceTypeName = pascalCase(`${endpoint}Service`);
-        // Service functions
+    for (const [serviceName, serviceEndpoints] of context.endpoints) {
+        const serviceFnName = camelCase(`${serviceName}Service`);
+        const serviceTypeName = pascalCase(`${serviceName}Service`);
         const functions = [];
-        for (const { path, endpoint } of paths) {
-            const resolver = generators[endpoint.type];
-            for (const [method, config] of Object.entries(path)) {
-                if (method === 'get' && endpoint.type === WeclappEndpointType.ENTITY && !options.generateUnique) {
+        for (const { path, endpoint } of serviceEndpoints) {
+            for (const method of [
+                OpenAPIV3.HttpMethods.GET,
+                OpenAPIV3.HttpMethods.POST,
+                OpenAPIV3.HttpMethods.PUT,
+                OpenAPIV3.HttpMethods.DELETE
+            ]) {
+                if ((method === OpenAPIV3.HttpMethods.GET &&
+                    endpoint.type === WeclappEndpointType.ENTITY &&
+                    !options.generateUnique) ||
+                    (method === OpenAPIV3.HttpMethods.POST &&
+                        (endpoint.type === WeclappEndpointType.COUNT || endpoint.path.endsWith('query')))) {
+                    // Skip unique endpoints if generateUnique option is not set or if POST is used for filter queries
                     continue;
                 }
-                if (resolver[method]) {
-                    const path = config;
-                    const target = options.target;
-                    if (!path.deprecated || options.deprecated) {
+                const operationObject = path[method];
+                const generatorFn = generators[endpoint.type][method];
+                if (operationObject && generatorFn) {
+                    if (!operationObject.deprecated || options.deprecated) {
                         functions.push({
-                            ...resolver[method]({ endpoint, method, target, path, aliases }),
-                            path
+                            ...generatorFn({
+                                method,
+                                endpoint,
+                                operationObject,
+                                entities,
+                                context,
+                                options
+                            }),
+                            path: operationObject
                         });
                     }
                 }
-                else {
-                    logger.errorLn(`Failed to generate a function for ${method.toUpperCase()}:${endpoint.type} ${endpoint.path}`);
-                }
             }
         }
         if (!functions.length) {
             continue;
         }
-        // Construct service type
-        const types = generateStatements(...functions.flatMap(v => v.interfaces?.map(v => v.source) ?? []), ...functions.map(v => v.type.source), generateInterface(serviceTypeName, [
-            ...functions.map(v => ({
+        const serviceTypes = generateStatements(...functions.flatMap((v) => generateBlockComment(`${serviceTypeName} - ${pascalCase(v.name)}`, generateStatements(...[...(v.interfaces?.map((v) => v.source) ?? []), v.type.source]))), generateBlockComment(`${serviceTypeName}`, generateInterface(serviceTypeName, [
+            ...functions.map((v) => ({
                 required: true,
                 comment: v.path.deprecated ? '@deprecated' : undefined,
                 name: v.func.name,
                 type: v.type.name
             }))
-        ]));
-        // Construct service value
-        const funcBody = generateBlockStatements(...functions.map(v => v.func.source), `return {${concat(functions.map(v => v.func.name))}};`);
-        const func = `export const ${serviceName} = (cfg?: ServiceConfig): ${serviceTypeName} => ${funcBody};`;
-        const source = generateBlockComment(`${pascalCase(endpoint)} service`, generateStatements(types, func));
-        const deprecated = functions.every(v => v.path.deprecated);
-        services.set(endpoint, { entity: endpoint, deprecated, serviceName, serviceTypeName, source, functions });
+        ])));
+        const serviceFn = `export const ${serviceFnName} = (cfg?: ServiceConfig): ${serviceTypeName} => ${generateBlockStatements(...functions.map((v) => v.func.source), `return {${concat(functions.map((v) => v.func.name))}};`)};`;
+        const relatedEntityName = context.aliases.get(serviceName);
+        const relatedEntity = relatedEntityName ? entities.get(relatedEntityName) : undefined;
+        services.set(serviceName, {
+            name: serviceName,
+            serviceFnName,
+            functions,
+            source: generateStatements(serviceTypes, serviceFn),
+            deprecated: functions.every((v) => v.path.deprecated),
+            relatedEntity
+        });
     }
     return services;
 };
 
-const generateCustomValueUtilities = (entities, services) => {
-    const customValueEntity = entities.get('customValue');
+const generateCustomValueServices = (services) => {
     const customValueEntities = [];
-    if (!customValueEntity) {
-        logger.warn('Cannot generate custom value utils, type not found.');
-        return '';
-    }
-    serviceLoop: for (const service of services) {
-        const someFunction = service.functions.find(v => v.name === 'some');
-        if (!someFunction) {
-            continue;
-        }
-        const entity = entities.get(camelCase(someFunction.entity));
-        if (entity?.properties.size !== customValueEntity.properties.size) {
-            continue;
-        }
-        for (const [prop, { type }] of entity.properties) {
-            if (customValueEntity.properties.get(prop)?.type !== type) {
-                continue serviceLoop;
-            }
+    for (const service of services) {
+        const relatedEntity = service.relatedEntity;
+        if (relatedEntity?.name === 'customValue') {
+            customValueEntities.push(service.name);
         }
-        customValueEntities.push(service.entity);
     }
-    return generateBlockComment('Utilities to identify services that return an entity that is an alias to CustomValue.', generateStatements(generateType('WCustomValueService', concat(generateStrings(customValueEntities), ' | ')), `export const wCustomValueServiceNames: WCustomValueService[] = [${concat(generateStrings(customValueEntities))}];`, `export const isWCustomValueService = (service: string | undefined): service is WCustomValueService =>\n${indent('wCustomValueServiceNames.includes(service as WCustomValueService);')}`));
+    return generateStatements(generateType('WCustomValueService', concat(generateStrings(customValueEntities), ' | ')), `export const wCustomValueServiceNames: WCustomValueService[] = [${concat(generateStrings(customValueEntities))}];`, `export const isWCustomValueService = (service: string | undefined): service is WCustomValueService =>\n${indent('wCustomValueServiceNames.includes(service as WCustomValueService);')}`);
 };
 
 const generateObject = (properties) => {
     const body = [];
-    for (const { key, value } of properties) {
+    for (const { key, value, comment } of properties) {
         if (value === undefined) {
             continue;
         }
         if (Array.isArray(value)) {
             const str = generateObject(value);
             if (str.length > 2) {
-                body.push(`${key}: ${str}`);
+                body.push(`${comment ? generateInlineComment(comment) + '\n' : ''}${key}: ${str}`);
             }
         }
         else {
-            body.push(`${key}: ${String(value)}`);
+            body.push(`${comment ? generateInlineComment(comment) + '\n' : ''}${key}: ${String(value)}`);
         }
     }
     return body.length ? `{\n${indent(body.join(',\n'))}\n}` : `{}`;
 };
 
 const resolveInheritedEntities = (root, entities) => {
-    const parent = root.extends ? entities.get(root.extends) : undefined;
+    const parent = root.parentName ? entities.get(root.parentName) : undefined;
     return parent ? [parent, ...resolveInheritedEntities(parent, entities)] : [];
 };
-const generatePropertyDescriptors = (entity, entities, services, options) => [
-    ...resolveInheritedEntities(entity, entities).flatMap(v => [...v.properties]),
-    ...entity.properties
-].filter(([, meta]) => {
+const generatePropertyDescriptors = (entity, entities, services, options) => [...resolveInheritedEntities(entity, entities).flatMap((v) => [...v.properties]), ...entity.properties]
+    .filter(([, meta]) => {
     // If we generate deprecated things we can skip the filtering
     if (options.deprecated) {
         return true;
     }
     // Check if corresponding service is deprecated and can be removed
-    const service = services.find(v => v.entity === meta.service);
+    const service = services.find((v) => v.name === meta.service);
     return !meta.service || (service && !service.deprecated);
-}).map(([property, meta]) => ({
+})
+    .map(([property, meta]) => ({
     key: property,
     value: Object.entries(meta).map(([key, value]) => ({
         key,
-        value: value ? generateString(value) : undefined
+        value: value !== undefined ? (typeof value === 'number' ? value : generateString(value)) : undefined
     }))
 }));
-const generateEntityPropertyMap = (entities, services, options) => {
+const generateEntityProperties = (entities, services, options) => {
     const typeName = 'WEntityProperties';
-    const propertyMap = [...entities].map(([entity, data]) => ({
-        key: entity,
-        value: generatePropertyDescriptors(data, entities, services, options)
+    const propertyMap = [
+        ...entities.entries(),
+        ...services
+            .filter(({ relatedEntity }) => !!relatedEntity)
+            .filter(({ name }) => !entities.get(name))
+            .map(({ name, relatedEntity }) => {
+            return [name, relatedEntity];
+        })
+    ].map(([entityName, entity]) => ({
+        key: entityName,
+        value: generatePropertyDescriptors(entity, entities, services, options)
     }));
     return generateStatements(`export type ${typeName} = Partial<Record<WEntity, Partial<Record<string, WEntityPropertyMeta>>>>;`, `export const wEntityProperties: ${typeName} = ${generateObject(propertyMap)};`);
 };
 
 const generateArray = (values) => {
-    return `[${concat(values.map(v => generateString(String(v))))}]`;
+    return `[${concat(values.map((v) => generateString(String(v))))}]`;
 };
 
 // Only functions matching this regex are included in the generation.
@@ -1014,16 +1160,17 @@ const FILTER_REGEX = /^(some|count|create|remove|unique|update)$/;
  */
 const generateGroupedServices = (services) => {
     const entityDescriptors = new Map();
-    for (const { entity, functions } of services) {
-        for (const { name } of functions) {
-            if (!FILTER_REGEX.test(name)) {
+    for (const service of services) {
+        for (const fn of service.functions) {
+            if (!FILTER_REGEX.test(fn.name)) {
                 continue;
             }
-            entityDescriptors.set(name, [
-                ...(entityDescriptors.get(name) ?? []), {
-                    name: entity,
+            entityDescriptors.set(fn.name, [
+                ...(entityDescriptors.get(fn.name) ?? []),
+                {
+                    name: service.name,
                     required: true,
-                    type: `${pascalCase(entity)}Service_${pascalCase(name)}`
+                    type: `${pascalCase(service.name)}Service_${pascalCase(fn.name)}`
                 }
             ]);
         }
@@ -1036,138 +1183,138 @@ const generateGroupedServices = (services) => {
         const guard = `(service: string | undefined): service is ${service} =>\n${indent(`${constant}.includes(service as ${service});`)}`;
         typeGuards.push(`export const is${service} = ${guard}`);
     }
-    return [
-        ...descriptors.map(([name, props]) => generateInterface(pascalCase(`WServicesWith_${name}`), props)),
-        ...descriptors.map(([name]) => generateType(pascalCase(`WServiceWith_${name}`), `keyof ${pascalCase(`WServicesWith_${name}`)}`)),
-        ...descriptors.map(([name, props]) => {
-            const constant = camelCase(`wServiceWith_${name}_Names`);
-            const type = pascalCase(`WServiceWith_${name}`);
-            const value = generateArray(props.map(v => v.name));
-            return `export const ${constant}: ${type}[] = ${value};`;
-        }),
-        generateBlockComment('Type guards for service classes.', generateStatements(...typeGuards))
-    ];
+    return generateStatements(...descriptors.map(([name, props]) => generateInterface(pascalCase(`WServicesWith_${name}`), props)), ...descriptors.map(([name]) => generateType(pascalCase(`WServiceWith_${name}`), `keyof ${pascalCase(`WServicesWith_${name}`)}`)), ...descriptors.map(([name, props]) => {
+        const constant = camelCase(`wServiceWith_${name}_Names`);
+        const type = pascalCase(`WServiceWith_${name}`);
+        const value = generateArray(props.map((v) => v.name));
+        return `export const ${constant}: ${type}[] = ${value};`;
+    }), ...typeGuards);
 };
 
-const obj = (list) => `{\n${indent(list.join(',\n'))}\n}`;
-const arr = (list) => `[\n${indent(list.join(',\n'))}\n]`;
-const generateMaps = ({ services, entities, aliases, enums, options }) => {
-    const entitiesKeys = [...entities.keys()];
-    const enumsArray = `export const wEnums = ${obj(enums)};`;
-    const entityNames = `export const wEntityNames: WEntity[] = ${arr(entitiesKeys.map(v => `'${v}'`))};`;
-    const serviceNames = `export const wServiceNames: WService[] = ${arr(services.map(v => `'${v.entity}'`))};`;
-    const serviceValues = `export const wServiceFactories = ${obj(services.map(v => `${v.entity}: ${v.serviceName}`))};`;
-    const serviceInstanceValues = `export const wServices = ${obj(services.map(v => {
-        const src = `${v.entity}: ${v.serviceName}()`;
-        return v.deprecated ? generateInlineComment('@deprecated') + `\n${src}` : src;
-    }))};`;
-    const entityInterfaces = [
-        ...entitiesKeys.map(entity => ({
-            name: entity,
-            type: pascalCase(entity),
+const generateMaps = (enums, entities, services, context, options) => {
+    const enumInstances = `export const wEnums = ${generateObject([...enums.keys()].map((v) => ({ key: v, value: v })))};`;
+    const entityNames = `export const wEntityNames: WEntity[] = ${generateArray([...entities.keys()])};`;
+    const generatedServices = [...services.values()];
+    const serviceInstances = `export const wServices = ${generateObject(generatedServices.map((v) => ({
+        key: v.name,
+        value: `${v.serviceFnName}()`,
+        comment: v.deprecated ? '@deprecated' : undefined
+    })))};`;
+    const serviceFactories = `export const wServiceFactories = ${generateObject(generatedServices.map((v) => ({
+        key: v.name,
+        value: v.serviceFnName,
+        comment: v.deprecated ? '@deprecated' : undefined
+    })))};`;
+    return generateStatements(
+    /* Enums */
+    generateInterface('WEnums', [...enums.keys()].map((name) => ({ name, type: name, required: true }))), generateType('WEnum', 'keyof WEnums'), enumInstances, 
+    /* Entities */
+    generateInterface('WEntities', [
+        ...[...entities.entries()].map(([name, entity]) => ({
+            name,
+            type: entity.interfaceName,
             required: true
         })),
-        ...services.map(service => {
-            const alias = aliases.get(service.entity);
-            return {
-                name: service.entity,
-                type: alias ?? 'never',
-                required: true,
-                comment: alias ? undefined : 'no response defined or inlined'
-            };
-        })
-    ];
-    const createMappingType = (type, prefix) => type !== 'never' ? `${type}_${prefix}` : type;
-    const entitiesList = generateInterface('WEntities', entityInterfaces);
-    const entityReferences = generateInterface('WEntityReferences', entityInterfaces.map(v => ({ ...v, type: createMappingType(v.type, 'References') })));
-    const entityMappings = generateInterface('WEntityMappings', entityInterfaces.map(v => ({ ...v, type: createMappingType(v.type, 'Mappings') })));
-    const entityFilter = generateInterface('WEntityFilters', entityInterfaces.map(v => ({ ...v, type: createMappingType(v.type, 'Filter') })));
-    return {
-        source: generateStatements(
-        /* JS Values */
-        serviceValues, serviceInstanceValues, entityNames, serviceNames, enumsArray, generateEntityPropertyMap(entities, services, options), 
-        /* Map of entity to references / mappings and filters*/
-        entityReferences, entityMappings, entityFilter, 
-        /* List of all entities with their corresponding service */
-        generateBlockComment(`
-                This interfaces merges two maps:
-                - Map<[entityName], [entityInterfaceName]>
-                - Map<[serviceName], [entityInterfaceName]>
-                
-                Where [entityName] is 
-                - the name of a nested entity (e.g. 'address' from Party)
-                - the name of an entity (e.g. 'party', 'article' etc.)
-                
-                Where [serviceName] is the name of an endpoint (e.g. for /article its 'article')
-               
-                Where [entityInterfaceName] is
-                - the underlying type for this entity
-                - the type for what is returned by the api
-            `, entitiesList), 
-        /* type-ofs and types */
-        generateType('WServices', 'typeof wServices'), generateType('WServiceFactories', 'typeof wServiceFactories'), generateType('WService', 'keyof WServices'), generateType('WEntity', 'keyof WEntities'), generateType('WEnums', 'typeof wEnums'), generateType('WEnum', 'keyof WEnums'), 
-        /* Utilities. */
-        generateCustomValueUtilities(entities, services), 
-        /* All functions grouped by service supporting it */
-        ...generateGroupedServices(services))
-    };
+        ...generatedServices
+            .filter(({ relatedEntity }) => !!relatedEntity)
+            .filter(({ name }) => !entities.get(name))
+            .map(({ name, relatedEntity }) => ({
+            name,
+            type: relatedEntity.interfaceName,
+            required: true
+        }))
+    ].sort((a, b) => (a.name > b.name ? 1 : -1))), generateType('WEntity', 'keyof WEntities'), entityNames, 
+    /* Services */
+    serviceInstances, generateType('WServices', 'typeof wServices'), generateType('WService', 'keyof WServices'), serviceFactories, generateType('WServiceFactories', 'typeof wServiceFactories'), 
+    /* Service Utils */
+    generateGroupedServices(generatedServices), generateCustomValueServices(generatedServices), 
+    /* Entity Properties (Runtime Meta Infos) */
+    generateEntityProperties(entities, generatedServices, options));
 };
 
-const parseReferencedEntity = (obj) => pascalCase(obj.$ref.replace(/.*\//, ''));
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-const extractSchemas = (doc) => {
-    const schemas = new Map();
+function extractRelatedEntityName(serviceEndpoints, responses) {
+    const rootEndpoint = serviceEndpoints.find((v) => v.endpoint.type === WeclappEndpointType.ROOT);
+    if (!rootEndpoint)
+        return;
+    const response = rootEndpoint?.path.get?.responses['200'];
+    if (!response)
+        return;
+    let responseObject;
+    if (isReferenceObject(response)) {
+        const refName = getRefName(response);
+        responseObject = responses.get(refName);
+    }
+    else {
+        responseObject = response;
+    }
+    const responseSchema = responseObject?.content?.['application/json'].schema;
+    if (responseSchema) {
+        if (isReferenceObject(responseSchema)) {
+            return;
+        }
+        const resultSchema = responseSchema.properties?.result;
+        if (!resultSchema) {
+            return;
+        }
+        if (isReferenceObject(resultSchema)) {
+            return getRefName(resultSchema);
+        }
+        else if (isArraySchemaObject(resultSchema)) {
+            const resultItemSchema = resultSchema.items;
+            if (isReferenceObject(resultItemSchema)) {
+                return getRefName(resultItemSchema);
+            }
+        }
+    }
+}
+
+const extractServiceAliases = (endpoints, responses) => {
     const aliases = new Map();
+    for (const [serviceName, serviceEndpoints] of endpoints) {
+        const relatedEntityName = extractRelatedEntityName(serviceEndpoints, responses);
+        if (relatedEntityName)
+            aliases.set(serviceName, relatedEntityName);
+    }
+    return aliases;
+};
+const extractContext = (doc) => {
+    const endpoints = parseEndpointsPaths(doc.paths);
+    const schemas = new Map();
     for (const [name, schema] of Object.entries(doc.components?.schemas ?? {})) {
         if (!isReferenceObject(schema)) {
             schemas.set(name, schema);
         }
     }
-    /**
-     * Referenced schemas in responses, in some case the response from the root endpoint
-     * refers to a schema with a different name
-     */
-    for (const [path, methods] of Object.entries(doc.paths)) {
-        const parsed = parseEndpointPath(path);
-        if (!parsed || schemas.has(parsed.entity)) {
-            continue;
+    const responses = new Map();
+    for (const [name, response] of Object.entries(doc.components?.responses ?? {})) {
+        if (!isReferenceObject(response)) {
+            responses.set(name, response);
         }
-        for (const method of Object.values(OpenAPIV3.HttpMethods)) {
-            const body = methods[method]?.responses['200'];
-            if (isResponseObject(body) && body.content) {
-                const responseSchema = Object.values(body.content)[0]?.schema;
-                if (isReferenceObject(responseSchema)) {
-                    continue;
-                }
-                const itemsSchema = responseSchema?.properties?.result;
-                if (isReferenceObject(itemsSchema)) {
-                    aliases.set(parsed.entity, parseReferencedEntity(itemsSchema));
-                    continue;
-                }
-                if (isArraySchemaObject(itemsSchema)) {
-                    const { items } = itemsSchema;
-                    if (isReferenceObject(items)) {
-                        aliases.set(parsed.entity, parseReferencedEntity(items));
-                    }
-                }
-            }
+    }
+    const parameters = new Map();
+    for (const [name, parameter] of Object.entries(doc.components?.parameters ?? {})) {
+        if (!isReferenceObject(parameter)) {
+            parameters.set(name, parameter);
+        }
+    }
+    const requestBodies = new Map();
+    for (const [name, requestBody] of Object.entries(doc.components?.requestBodies ?? {})) {
+        if (!isReferenceObject(requestBody)) {
+            requestBodies.set(name, requestBody);
         }
     }
-    return { schemas, aliases };
+    const aliases = extractServiceAliases(endpoints, responses);
+    return { endpoints, schemas, responses, parameters, requestBodies, aliases };
 };
 
 const generate = (doc, options) => {
-    const { schemas, aliases } = extractSchemas(doc);
-    const enums = generateEnums(schemas);
-    const entities = generateEntities(schemas, enums);
-    const services = generateServices(doc, aliases, options);
-    return generateStatements(generateBase(options.target), generateBlockComment('ENUMS', generateStatements(...[...enums.values()].map(v => v.source))), generateBlockComment('ENTITIES', generateStatements(...[...entities.values()].map(v => v.source))), generateBlockComment('SERVICES', generateStatements(...[...services.values()].map(v => v.source))), generateBlockComment('MAPS', generateMaps({
-        services: [...services.values()],
-        enums: [...enums.keys()],
-        options,
-        entities,
-        aliases
-    }).source));
+    const context = extractContext(doc);
+    const base = generateBase(doc.info.version, options);
+    const enums = generateEnums(context);
+    const entities = generateEntities(context);
+    const services = generateServices(entities, context, options);
+    const maps = generateMaps(enums, entities, services, context, options);
+    return generateStatements(generateBlockComment('BASE', base), generateBlockComment('ENUMS', generateStatements(...[...enums.values()].map((v) => v.source))), generateBlockComment('ENTITIES', generateStatements(...[...entities.values()].map((v) => v.source))), generateBlockComment('FILTERS', generateStatements(...[...entities.values()].map((v) => v.filterSource))), generateBlockComment('SERVICES', generateStatements(...[...services.values()].map((v) => v.source))), generateBlockComment('MAPS', maps));
 };
 
 const hash = (content, algorithm = 'sha256') => {
@@ -1183,12 +1330,13 @@ const hash = (content, algorithm = 'sha256') => {
 
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 const cli = async () => {
-    const { default: { version } } = await import('../package.json', { assert: { type: 'json' } });
+    const version = pkg.version;
     const { argv } = yargs(hideBin(process.argv))
         .scriptName('build-weclapp-sdk')
         .usage('Usage: $0 <source> [flags]')
         .version(version)
         .example('$0 openapi.json', 'Generate the SDK based on a local openapi file')
+        .example('$0 openapi.json', 'Generate the SDK based on a local openapi file')
         .example('$0 xxx.weclapp.com --key ...', 'Generate the SDK based on the openapi file from the given weclapp instance')
         .help('h')
         .alias('v', 'version')
@@ -1228,36 +1376,47 @@ const cli = async () => {
         type: 'string',
         choices: ['browser', 'browser.rx', 'node', 'node.rx']
     })
-        .option('d', {
-        alias: 'deprecated',
-        describe: 'Include deprecated functions and services',
+        .option('use-query-language', {
+        describe: 'Generate the new where property for some and count queries',
         type: 'boolean'
+    })
+        .option('apiVersion', {
+        describe: 'Specify the api version (only needed when not using a local file)',
+        type: 'string'
     })
         .epilog(`Copyright ${new Date().getFullYear()} weclapp GmbH`);
     if (argv.fromEnv) {
         config();
     }
     const { WECLAPP_API_KEY, WECLAPP_BACKEND_URL } = process.env;
-    const { query, cache = false, deprecated = false, key = WECLAPP_API_KEY, _: [src = WECLAPP_BACKEND_URL] } = argv;
+    const { query, cache = false, deprecated = false, key = WECLAPP_API_KEY, apiVersion, _: [src = WECLAPP_BACKEND_URL] } = argv;
     const options = {
         deprecated,
         generateUnique: argv.generateUnique ?? false,
-        target: argv.target ?? Target.BROWSER_PROMISES
+        target: argv.target ?? Target.BROWSER_PROMISES,
+        useQueryLanguage: argv.useQueryLanguage ?? false
     };
-    if (typeof src === 'number') {
-        return Promise.reject('Expected string as command');
+    if (!src || typeof src === 'number') {
+        return Promise.reject(new Error('Expected string as command'));
     }
     if (!Object.values(Target).includes(options.target)) {
         logger.errorLn(`Unknown target: ${options.target}. Possible values are ${Object.values(Target).join(', ')}`);
-        return Promise.reject();
+        return Promise.reject(new Error());
     }
     if (await stat(src).catch(() => false)) {
-        logger.infoLn(`Source is a file.`);
+        logger.infoLn(`Source is a file`);
         const content = JSON.parse(await readFile(src, 'utf-8'));
         return { cache, content, options };
     }
+    logger.infoLn(`Source is a URL`);
+    if (!key) {
+        return Promise.reject(new Error('API key is missing'));
+    }
+    if (!apiVersion) {
+        return Promise.reject(new Error('API version is missing'));
+    }
     const url = new URL(src.startsWith('http') ? src : `https://${src}`);
-    url.pathname = '/webapp/api/v1/meta/openapi.json';
+    url.pathname = `/webapp/api/${apiVersion}/meta/openapi.json`;
     if (query?.length) {
         for (const param of query.split(',')) {
             const [name, value] = param.split('=');
@@ -1265,11 +1424,11 @@ const cli = async () => {
         }
     }
     const content = await fetch(url.toString(), {
-        headers: { 'Accept': 'application/json', 'AuthenticationToken': key }
-    }).then(res => res.ok ? res.json() : undefined);
+        headers: { Accept: 'application/json', AuthenticationToken: key }
+    }).then((res) => (res.ok ? res.json() : undefined));
     if (!content) {
         logger.errorLn(`Couldn't fetch file ${url.toString()} `);
-        return Promise.reject();
+        return Promise.reject(new Error());
     }
     else {
         logger.infoLn(`Use remote file: ${url.toString()}`);
@@ -1277,50 +1436,59 @@ const cli = async () => {
     return { cache, content, options };
 };
 
-const workingDirectory = resolve(currentDirname(), './sdk');
-const folders = ['docs', 'main', 'node', 'raw', 'rx', 'utils'];
+const workingDir = resolve(currentDirname(), './sdk');
+const cacheDir = resolve(currentDirname(), './.cache');
 void (async () => {
     const start = process.hrtime.bigint();
-    const { default: { version } } = await import('../package.json', { assert: { type: 'json' } });
     const { content: doc, cache: useCache, options } = await cli();
-    // Resolve cache dir and key
-    const cacheKey = hash([version, JSON.stringify(doc), JSON.stringify(options)]).slice(-8);
-    const cacheDir = resolve(currentDirname(), '.tmp', cacheKey);
-    const dist = (...paths) => resolve(workingDirectory, ...paths);
-    const tmp = async (...paths) => {
-        const fullPath = resolve(cacheDir, ...paths);
-        await mkdir(dirname(fullPath), { recursive: true }).catch(() => null);
+    const workingDirPath = async (...paths) => {
+        const fullPath = resolve(workingDir, ...paths);
+        await mkdir(dirname(fullPath), { recursive: true });
         return fullPath;
     };
+    // Resolve cache dir and key
+    const cacheKey = hash([pkg.version, JSON.stringify(doc), JSON.stringify(options)]).slice(-8);
+    const cachedSdkDir = resolve(cacheDir, cacheKey);
+    // Remove old SDK
+    await rm(workingDir, { recursive: true, force: true });
     if (useCache) {
         logger.infoLn(`Cache ID: ${cacheKey}`);
     }
-    if (useCache && await stat(cacheDir).catch(() => false)) {
-        logger.successLn(`Cache match! (${cacheDir})`);
+    if (useCache && (await stat(cachedSdkDir).catch(() => false))) {
+        // Copy cached SDK to working dir
+        logger.successLn(`Cache match! (${cachedSdkDir})`);
+        await cp(cachedSdkDir, workingDir, { recursive: true });
     }
     else {
-        // Store swagger.json file
-        await writeFile(await tmp('openapi.json'), JSON.stringify(doc, null, 2));
+        // Write openapi.json file
+        await writeFile(await workingDirPath('openapi.json'), JSON.stringify(doc, null, 2));
         logger.infoLn(`Generate sdk (target: ${options.target})`);
-        // Generate SDKs
+        // Generate and write SDK (index.ts)
         const sdk = generate(doc, options);
-        await writeFile(await tmp('src', `${options.target}.ts`), sdk.trim() + '\n');
-        // Bundle
+        await writeFile(await workingDirPath('src', 'index.ts'), sdk.trim() + '\n');
+        // Bundle and write SDK
         logger.infoLn('Bundle... (this may take some time)');
-        await bundle(cacheDir, options.target);
-        // Remove old SDK
-        await Promise.all(folders.map(async (dir) => rm(dist(dir), { recursive: true }).catch(() => 0)));
+        await bundle(workingDir, options.target);
+        // Remove index.ts (only bundle is required)
+        await rm(await workingDirPath('src'), { recursive: true, force: true });
+        if (useCache) {
+            // Copy SDK to cache
+            logger.successLn(`Caching SDK: (${cachedSdkDir})`);
+            await mkdir(cachedSdkDir, { recursive: true });
+            await cp(workingDir, cachedSdkDir, { recursive: true });
+        }
     }
-    // Copy bundled SDK
-    await cp(cacheDir, workingDirectory, { recursive: true });
     // Print job summary
     const duration = (process.hrtime.bigint() - start) / 1000000n;
     logger.successLn(`SDK built in ${prettyMs(Number(duration))}`);
     logger.printSummary();
-})().catch((error) => {
+})()
+    .catch((error) => {
     logger.errorLn(`Fatal error:`);
     /* eslint-disable no-console */
     console.error(error);
-}).finally(() => {
-    logger.errors && process.exit(1);
+})
+    .finally(() => {
+    if (logger.errors)
+        process.exit(1);
 });