@crowdstrike/foundry-js 0.2.2 → 0.5.0

package/dist/index.js

@@ -1,3 +1,183 @@
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
+    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+
+    if (!getRandomValues) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+
+  return getRandomValues(rnds8);
+}
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+
+const byteToHex = [];
+
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+
+function unsafeStringify(arr, offset = 0) {
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native = {
+  randomUUID
+};
+
+function v4(options, buf, offset) {
+  if (native.randomUUID && !buf && !options) {
+    return native.randomUUID();
+  }
+
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  if (buf) {
+    offset = offset || 0;
+
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+
+    return buf;
+  }
+
+  return unsafeStringify(rnds);
+}
+
+const VERSION = 'current';
+
+function assertConnection(falcon) {
+    if (!falcon.isConnected) {
+        throw new Error('You cannot call this API before having established a connection to the host!');
+    }
+}
+function isValidResponse(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+event) {
+    return !!event?.data?.meta?.messageId;
+}
+
+const CONNECTION_TIMEOUT = 5_000;
+const API_TIMEOUT = 30_000;
+const NAVIGATION_TIMEOUT = 5_000;
+function timeoutForMessage(message) {
+    const timeout = message.type === 'connect'
+        ? CONNECTION_TIMEOUT
+        : message.type === 'api'
+            ? API_TIMEOUT
+            : message.type === 'navigateTo'
+                ? NAVIGATION_TIMEOUT
+                : // Requests not explicitly covered above will not have a timeout. This includes 'fileUpload', which is a user interaction that can take any amount of time.
+                    null;
+    // In tests we have mocked responses which do not require long timeouts
+    return timeout !== null && false ? 40 : timeout;
+}
+class Bridge {
+    onDataUpdate;
+    onBroadcast;
+    onLivereload;
+    pendingMessages = new Map();
+    targetOrigin = '*';
+    constructor({ onDataUpdate, onBroadcast, onLivereload, } = {}) {
+        this.onDataUpdate = onDataUpdate;
+        this.onBroadcast = onBroadcast;
+        this.onLivereload = onLivereload;
+        window.addEventListener('message', this.handleMessage);
+    }
+    destroy() {
+        window.removeEventListener('message', this.handleMessage);
+    }
+    setOrigin(origin) {
+        this.targetOrigin = origin;
+    }
+    sendUnidirectionalMessage(message) {
+        const messageId = v4();
+        const eventData = {
+            message,
+            meta: {
+                messageId,
+                version: VERSION,
+            },
+        };
+        window.parent.postMessage(eventData, this.targetOrigin);
+    }
+    // TODO: For some reason with adding more APIs, return type is not working
+    // Promise<PayloadOf<ResponseFor<REQ, DATA>>>
+    async postMessage(message) {
+        return new Promise((resolve, reject) => {
+            const messageId = v4();
+            let timeoutTimer;
+            const timeoutValue = timeoutForMessage(message);
+            if (timeoutValue !== null) {
+                timeoutTimer = setTimeout(() => {
+                    reject(new Error(`Waiting for response from foundry host for "${message.type}" message (ID: ${messageId}) timed out after ${timeoutValue}ms`));
+                }, timeoutValue);
+            }
+            this.pendingMessages.set(messageId, (result) => {
+                if (timeoutTimer) {
+                    clearTimeout(timeoutTimer);
+                }
+                resolve(result);
+            });
+            const eventData = {
+                message,
+                meta: {
+                    messageId,
+                    version: VERSION,
+                },
+            };
+            window.parent.postMessage(eventData, this.targetOrigin);
+        });
+    }
+    handleMessage = (event) => {
+        if (!isValidResponse(event)) {
+            return;
+        }
+        const { message } = event.data;
+        if (message.type === 'data') {
+            this.onDataUpdate?.(message);
+            // data update events are unidirectional and originated from the host, so there cannot be a callback waiting for this message
+            return;
+        }
+        if (message.type === 'broadcast') {
+            this.onBroadcast?.(message);
+            // data update events are unidirectional and are proxied via the host, so there cannot be a callback waiting for this message
+            return;
+        }
+        if (message.type === 'livereload') {
+            this.onLivereload?.(message);
+            // livereload events are unidirectional and are proxied via the host, so there cannot be a callback waiting for this message
+            return;
+        }
+        const { messageId } = event.data.meta;
+        const callback = this.pendingMessages.get(messageId);
+        if (!callback) {
+            throw new Error(`Received unexpected message`);
+        }
+        this.pendingMessages.delete(messageId);
+        callback(message.payload);
+    };
+}
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -20,237 +200,30 @@ function __decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 
-function Memoize(args) {
-    let hashFunction;
-    let duration;
-    let tags;
-    if (typeof args === 'object') {
-        hashFunction = args.hashFunction;
-        duration = args.expiring;
-        tags = args.tags;
-    }
-    else {
-        hashFunction = args;
-    }
-    return (target, propertyKey, descriptor) => {
-        if (descriptor.value != null) {
-            descriptor.value = getNewFunction(descriptor.value, hashFunction, duration, tags);
-        }
-        else if (descriptor.get != null) {
-            descriptor.get = getNewFunction(descriptor.get, hashFunction, duration, tags);
-        }
-        else {
-            throw 'Only put a Memoize() decorator on a method or get accessor.';
-        }
-    };
+const anyMap = new WeakMap();
+const eventsMap = new WeakMap();
+const producersMap = new WeakMap();
+
+const anyProducer = Symbol('anyProducer');
+const resolvedPromise = Promise.resolve();
+
+// Define symbols for "meta" events.
+const listenerAdded = Symbol('listenerAdded');
+const listenerRemoved = Symbol('listenerRemoved');
+
+let canEmitMetaEvents = false;
+let isGlobalDebugEnabled = false;
+
+function assertEventName(eventName) {
+	if (typeof eventName !== 'string' && typeof eventName !== 'symbol' && typeof eventName !== 'number') {
+		throw new TypeError('`eventName` must be a string, symbol, or number');
+	}
 }
-const clearCacheTagsMap = new Map();
-function getNewFunction(originalMethod, hashFunction, duration = 0, tags) {
-    const propMapName = Symbol(`__memoized_map__`);
-    return function (...args) {
-        let returnedValue;
-        if (!this.hasOwnProperty(propMapName)) {
-            Object.defineProperty(this, propMapName, {
-                configurable: false,
-                enumerable: false,
-                writable: false,
-                value: new Map()
-            });
-        }
-        let myMap = this[propMapName];
-        if (Array.isArray(tags)) {
-            for (const tag of tags) {
-                if (clearCacheTagsMap.has(tag)) {
-                    clearCacheTagsMap.get(tag).push(myMap);
-                }
-                else {
-                    clearCacheTagsMap.set(tag, [myMap]);
-                }
-            }
-        }
-        if (hashFunction || args.length > 0 || duration > 0) {
-            let hashKey;
-            if (hashFunction === true) {
-                hashKey = args.map(a => a.toString()).join('!');
-            }
-            else if (hashFunction) {
-                hashKey = hashFunction.apply(this, args);
-            }
-            else {
-                hashKey = args[0];
-            }
-            const timestampKey = `${hashKey}__timestamp`;
-            let isExpired = false;
-            if (duration > 0) {
-                if (!myMap.has(timestampKey)) {
-                    isExpired = true;
-                }
-                else {
-                    let timestamp = myMap.get(timestampKey);
-                    isExpired = (Date.now() - timestamp) > duration;
-                }
-            }
-            if (myMap.has(hashKey) && !isExpired) {
-                returnedValue = myMap.get(hashKey);
-            }
-            else {
-                returnedValue = originalMethod.apply(this, args);
-                myMap.set(hashKey, returnedValue);
-                if (duration > 0) {
-                    myMap.set(timestampKey, Date.now());
-                }
-            }
-        }
-        else {
-            const hashKey = this;
-            if (myMap.has(hashKey)) {
-                returnedValue = myMap.get(hashKey);
-            }
-            else {
-                returnedValue = originalMethod.apply(this, args);
-                myMap.set(hashKey, returnedValue);
-            }
-        }
-        return returnedValue;
-    };
-}
-
-/**
- *
- * This file is autogenerated.
- *
- * DO NOT EDIT DIRECTLY
- *
- **/
-class IncidentsApiBridge {
-    bridge;
-    constructor(bridge) {
-        this.bridge = bridge;
-    }
-    async getIncidentIds(urlParams = {}) {
-        const message = {
-            type: 'api',
-            api: 'incidents',
-            method: 'getQueriesIncidentsV1',
-            payload: {
-                params: urlParams,
-            },
-        };
-        return this.bridge.postMessage(message);
-    }
-    async getIncidentEntities(postBody, urlParams = {}) {
-        const message = {
-            type: 'api',
-            api: 'incidents',
-            method: 'postEntitiesIncidentsGetV1',
-            payload: {
-                body: postBody,
-                params: urlParams,
-            },
-        };
-        return this.bridge.postMessage(message);
-    }
-}
-
-/**
- *
- * This file is autogenerated.
- *
- * DO NOT EDIT DIRECTLY
- *
- **/
-class RemoteResponseApiBridge {
-    bridge;
-    constructor(bridge) {
-        this.bridge = bridge;
-    }
-    async getScriptIds(urlParams = {}) {
-        const message = {
-            type: 'api',
-            api: 'remoteResponse',
-            method: 'getQueriesScriptsV1',
-            payload: { params: urlParams },
-        };
-        return this.bridge.postMessage(message);
-    }
-    async getScriptEntities(postBody, urlParams = {}) {
-        const message = {
-            type: 'api',
-            api: 'remoteResponse',
-            method: 'postEntitiesScriptsGetV2',
-            payload: { body: postBody, params: urlParams },
-        };
-        return this.bridge.postMessage(message);
-    }
-}
-
-function assertConnection(falcon) {
-    if (!falcon.isConnected) {
-        throw new Error('You cannot call this API before having established a connection to the host!');
-    }
-}
-function isValidResponse(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-event) {
-    return !!event?.data?.meta?.messageId;
-}
-
-/**
- *
- * This file is autogenerated from the available APIs for App Platform.
- *
- * DO NOT EDIT DIRECTLY
- *
- * If you need to change the contents of this file please edit the above configuration file and
- * then run:
- *
- * ```
- * yarn cs-gen platform-apis
- * ```
- *
- **/
-class FalconPublicApis {
-    isConnected = false;
-    get incidents() {
-        assertConnection(this);
-        return new IncidentsApiBridge(this.bridge);
-    }
-    get remoteResponse() {
-        assertConnection(this);
-        return new RemoteResponseApiBridge(this.bridge);
-    }
-}
-__decorate([
-    Memoize()
-], FalconPublicApis.prototype, "incidents", null);
-__decorate([
-    Memoize()
-], FalconPublicApis.prototype, "remoteResponse", null);
-
-const anyMap = new WeakMap();
-const eventsMap = new WeakMap();
-const producersMap = new WeakMap();
-
-const anyProducer = Symbol('anyProducer');
-const resolvedPromise = Promise.resolve();
-
-// Define symbols for "meta" events.
-const listenerAdded = Symbol('listenerAdded');
-const listenerRemoved = Symbol('listenerRemoved');
-
-let canEmitMetaEvents = false;
-let isGlobalDebugEnabled = false;
-
-function assertEventName(eventName) {
-	if (typeof eventName !== 'string' && typeof eventName !== 'symbol' && typeof eventName !== 'number') {
-		throw new TypeError('`eventName` must be a string, symbol, or number');
-	}
-}
-
-function assertListener(listener) {
-	if (typeof listener !== 'function') {
-		throw new TypeError('listener must be a function');
-	}
+
+function assertListener(listener) {
+	if (typeof listener !== 'function') {
+		throw new TypeError('listener must be a function');
+	}
 }
 
 function getListeners(instance, eventName) {
@@ -764,126 +737,1963 @@ Object.defineProperty(Emittery, 'listenerRemoved', {
 	configurable: false,
 });
 
-// Unique ID creation requires a high quality random # generator. In the browser we therefore
-// require the crypto API and do not support built-in fallback to lower quality random number
-// generators (like Math.random()).
-let getRandomValues;
-const rnds8 = new Uint8Array(16);
-function rng() {
-  // lazy load so that environments that need to polyfill have a chance to do so
-  if (!getRandomValues) {
-    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
-    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+function Memoize(args) {
+    let hashFunction;
+    let duration;
+    let tags;
+    if (typeof args === 'object') {
+        hashFunction = args.hashFunction;
+        duration = args.expiring;
+        tags = args.tags;
+    }
+    else {
+        hashFunction = args;
+    }
+    return (target, propertyKey, descriptor) => {
+        if (descriptor.value != null) {
+            descriptor.value = getNewFunction(descriptor.value, hashFunction, duration, tags);
+        }
+        else if (descriptor.get != null) {
+            descriptor.get = getNewFunction(descriptor.get, hashFunction, duration, tags);
+        }
+        else {
+            throw 'Only put a Memoize() decorator on a method or get accessor.';
+        }
+    };
+}
+const clearCacheTagsMap = new Map();
+function getNewFunction(originalMethod, hashFunction, duration = 0, tags) {
+    const propMapName = Symbol(`__memoized_map__`);
+    return function (...args) {
+        let returnedValue;
+        if (!this.hasOwnProperty(propMapName)) {
+            Object.defineProperty(this, propMapName, {
+                configurable: false,
+                enumerable: false,
+                writable: false,
+                value: new Map()
+            });
+        }
+        let myMap = this[propMapName];
+        if (Array.isArray(tags)) {
+            for (const tag of tags) {
+                if (clearCacheTagsMap.has(tag)) {
+                    clearCacheTagsMap.get(tag).push(myMap);
+                }
+                else {
+                    clearCacheTagsMap.set(tag, [myMap]);
+                }
+            }
+        }
+        if (hashFunction || args.length > 0 || duration > 0) {
+            let hashKey;
+            if (hashFunction === true) {
+                hashKey = args.map(a => a.toString()).join('!');
+            }
+            else if (hashFunction) {
+                hashKey = hashFunction.apply(this, args);
+            }
+            else {
+                hashKey = args[0];
+            }
+            const timestampKey = `${hashKey}__timestamp`;
+            let isExpired = false;
+            if (duration > 0) {
+                if (!myMap.has(timestampKey)) {
+                    isExpired = true;
+                }
+                else {
+                    let timestamp = myMap.get(timestampKey);
+                    isExpired = (Date.now() - timestamp) > duration;
+                }
+            }
+            if (myMap.has(hashKey) && !isExpired) {
+                returnedValue = myMap.get(hashKey);
+            }
+            else {
+                returnedValue = originalMethod.apply(this, args);
+                myMap.set(hashKey, returnedValue);
+                if (duration > 0) {
+                    myMap.set(timestampKey, Date.now());
+                }
+            }
+        }
+        else {
+            const hashKey = this;
+            if (myMap.has(hashKey)) {
+                returnedValue = myMap.get(hashKey);
+            }
+            else {
+                returnedValue = originalMethod.apply(this, args);
+                myMap.set(hashKey, returnedValue);
+            }
+        }
+        return returnedValue;
+    };
+}
 
-    if (!getRandomValues) {
-      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class ActorsApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async getEntitiesActorsGetV2(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'actors',
+            method: 'getEntitiesActorsGetV2',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesActorsV2(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'actors',
+            method: 'getQueriesActorsV2',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postAggregatesActorsGetV2(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'actors',
+            method: 'postAggregatesActorsGetV2',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesActorsGetV2(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'actors',
+            method: 'postEntitiesActorsGetV2',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesMitreV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'actors',
+            method: 'postEntitiesMitreV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class AlertsApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async deleteEntitiesSuppressedDevicesV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'alerts',
+            method: 'deleteEntitiesSuppressedDevicesV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesAlertsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'alerts',
+            method: 'getQueriesAlertsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async patchCombinedAlertsV2(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'alerts',
+            method: 'patchCombinedAlertsV2',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async patchEntitiesAlertsV2(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'alerts',
+            method: 'patchEntitiesAlertsV2',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async patchEntitiesSuppressedDevicesV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'alerts',
+            method: 'patchEntitiesSuppressedDevicesV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postAggregatesAlertsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'alerts',
+            method: 'postAggregatesAlertsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesAlertsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'alerts',
+            method: 'postEntitiesAlertsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesSuppressedDevicesV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'alerts',
+            method: 'postEntitiesSuppressedDevicesV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class CustomobjectsApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async deleteV1CollectionsCollectionNameObjectsObjectKey(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'customobjects',
+            method: 'deleteV1CollectionsCollectionNameObjectsObjectKey',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getV1Collections(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'customobjects',
+            method: 'getV1Collections',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getV1CollectionsCollectionNameObjects(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'customobjects',
+            method: 'getV1CollectionsCollectionNameObjects',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getV1CollectionsCollectionNameObjectsObjectKey(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'customobjects',
+            method: 'getV1CollectionsCollectionNameObjectsObjectKey',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getV1CollectionsCollectionNameObjectsObjectKeyMetadata(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'customobjects',
+            method: 'getV1CollectionsCollectionNameObjectsObjectKeyMetadata',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postV1CollectionsCollectionNameObjects(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'customobjects',
+            method: 'postV1CollectionsCollectionNameObjects',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async putV1CollectionsCollectionNameObjectsObjectKey(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'customobjects',
+            method: 'putV1CollectionsCollectionNameObjectsObjectKey',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class DetectsApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async getEntitiesSuppressedDevicesV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'detects',
+            method: 'getEntitiesSuppressedDevicesV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async patchEntitiesDetectsV2(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'detects',
+            method: 'patchEntitiesDetectsV2',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async patchQueriesDetectsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'detects',
+            method: 'patchQueriesDetectsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async patchQueriesDetectsV2(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'detects',
+            method: 'patchQueriesDetectsV2',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postAggregatesDetectsGetV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'detects',
+            method: 'postAggregatesDetectsGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesSummariesGetV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'detects',
+            method: 'postEntitiesSummariesGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesSuppressedDevicesV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'detects',
+            method: 'postEntitiesSuppressedDevicesV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class DevicesApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async deleteEntitiesGroupsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'deleteEntitiesGroupsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getAggregatesBucketsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'getAggregatesBucketsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getAggregatesTagPrefixCountsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'getAggregatesTagPrefixCountsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getEntitiesGroupsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'getEntitiesGroupsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getEntitiesReleasesV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'getEntitiesReleasesV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getEntitiesRespondV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'getEntitiesRespondV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesAvailableGroupsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'getQueriesAvailableGroupsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesDevicesHiddenV2(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'getQueriesDevicesHiddenV2',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesDevicesV2(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'getQueriesDevicesV2',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesGroupsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'getQueriesGroupsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async patchEntitiesDevicesTagsV2(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'patchEntitiesDevicesTagsV2',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async patchEntitiesGroupsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'patchEntitiesGroupsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postAggregatesDevicesGetV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'postAggregatesDevicesGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postCombinedDevicesLoginHistoryV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'postCombinedDevicesLoginHistoryV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesDevicesActionsV4(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'postEntitiesDevicesActionsV4',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesDevicesHiddenActionsV4(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'postEntitiesDevicesHiddenActionsV4',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesDevicesReportsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'postEntitiesDevicesReportsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesDevicesV2(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'postEntitiesDevicesV2',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesGroupActionsV1(postBody, urlParams) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'postEntitiesGroupActionsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesGroupsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'postEntitiesGroupsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesReleasesV1(postBody, urlParams) {
+        const message = {
+            type: 'api',
+            api: 'devices',
+            method: 'postEntitiesReleasesV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class FaasGatewayApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async getEntitiesExecutionV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'faasGateway',
+            method: 'getEntitiesExecutionV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesExecutionV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'faasGateway',
+            method: 'postEntitiesExecutionV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class FwmgrApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async deleteEntitiesNetworkLocationsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'deleteEntitiesNetworkLocationsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async deleteEntitiesPoliciesV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'deleteEntitiesPoliciesV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async deleteEntitiesRuleGroupsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'deleteEntitiesRuleGroupsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getEntitiesEventsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getEntitiesEventsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getEntitiesFirewallFieldsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getEntitiesFirewallFieldsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getEntitiesNetworkLocationsDetailsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getEntitiesNetworkLocationsDetailsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getEntitiesNetworkLocationsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getEntitiesNetworkLocationsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getEntitiesPlatformsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getEntitiesPlatformsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getEntitiesPoliciesV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getEntitiesPoliciesV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getEntitiesRuleGroupsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getEntitiesRuleGroupsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getEntitiesRulesV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getEntitiesRulesV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getLibraryEntitiesRuleGroupsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getLibraryEntitiesRuleGroupsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getLibraryQueriesRuleGroupsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getLibraryQueriesRuleGroupsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesEventsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getQueriesEventsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesFirewallFieldsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getQueriesFirewallFieldsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesNetworkLocationsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getQueriesNetworkLocationsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesPlatformsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getQueriesPlatformsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesPolicyRulesV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getQueriesPolicyRulesV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesRuleGroupsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getQueriesRuleGroupsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesRulesV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'getQueriesRulesV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async patchEntitiesNetworkLocationsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'patchEntitiesNetworkLocationsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async patchEntitiesRuleGroupsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'patchEntitiesRuleGroupsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postAggregatesEventsGetV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'postAggregatesEventsGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postAggregatesPolicyRulesGetV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'postAggregatesPolicyRulesGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postAggregatesRuleGroupsGetV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'postAggregatesRuleGroupsGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postAggregatesRulesGetV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'postAggregatesRulesGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesNetworkLocationsMetadataV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'postEntitiesNetworkLocationsMetadataV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesNetworkLocationsPrecedenceV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'postEntitiesNetworkLocationsPrecedenceV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesNetworkLocationsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'postEntitiesNetworkLocationsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesOntologyV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'postEntitiesOntologyV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesRuleGroupsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'postEntitiesRuleGroupsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesRulesValidateFilepathV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'postEntitiesRulesValidateFilepathV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async putEntitiesNetworkLocationsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'putEntitiesNetworkLocationsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async putEntitiesPoliciesV2(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'fwmgr',
+            method: 'putEntitiesPoliciesV2',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class IncidentsApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async getCombinedCrowdscoresV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'incidents',
+            method: 'getCombinedCrowdscoresV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesBehaviorsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'incidents',
+            method: 'getQueriesBehaviorsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getQueriesIncidentsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'incidents',
+            method: 'getQueriesIncidentsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postAggregatesBehaviorsGetV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'incidents',
+            method: 'postAggregatesBehaviorsGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postAggregatesIncidentsGetV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'incidents',
+            method: 'postAggregatesIncidentsGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesBehaviorsGetV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'incidents',
+            method: 'postEntitiesBehaviorsGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesIncidentActionsV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'incidents',
+            method: 'postEntitiesIncidentActionsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesIncidentsGetV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'incidents',
+            method: 'postEntitiesIncidentsGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class LoggingapiApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async getEntitiesSavedSearchesExecuteV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'loggingapi',
+            method: 'getEntitiesSavedSearchesExecuteV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesSavedSearchesExecuteV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'loggingapi',
+            method: 'postEntitiesSavedSearchesExecuteV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class MitreApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async getEntitiesMatrixV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'mitre',
+            method: 'getEntitiesMatrixV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class PluginsApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async getEntitiesConfigsV1(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'plugins',
+            method: 'getEntitiesConfigsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesExecuteDraftV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'plugins',
+            method: 'postEntitiesExecuteDraftV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesExecuteV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'plugins',
+            method: 'postEntitiesExecuteV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class RemoteResponseApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async getScriptIds(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'remoteResponse',
+            method: 'getQueriesScriptsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getScriptEntities(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'remoteResponse',
+            method: 'postEntitiesScriptsGetV2',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class WorkflowsApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getBridge() {
+        return this.bridge;
+    }
+    async getEntitiesExecutionResultsV1(urlParams) {
+        const message = {
+            type: 'api',
+            api: 'workflows',
+            method: 'getEntitiesExecutionResultsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesExecuteV1(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'workflows',
+            method: 'postEntitiesExecuteV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async postEntitiesExecutionActionsV1(postBody, urlParams) {
+        const message = {
+            type: 'api',
+            api: 'workflows',
+            method: 'postEntitiesExecutionActionsV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated from the available APIs for App Platform.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ * If you need to change the contents of this file please edit the above configuration file and
+ * then run:
+ *
+ * ```
+ * yarn cs-gen platform-apis
+ * ```
+ *
+ **/
+class FalconPublicApis {
+    isConnected = false;
+    get actors() {
+        assertConnection(this);
+        return new ActorsApiBridge(this.bridge);
+    }
+    get alerts() {
+        assertConnection(this);
+        return new AlertsApiBridge(this.bridge);
+    }
+    get detects() {
+        assertConnection(this);
+        return new DetectsApiBridge(this.bridge);
+    }
+    get devices() {
+        assertConnection(this);
+        return new DevicesApiBridge(this.bridge);
+    }
+    get fwmgr() {
+        assertConnection(this);
+        return new FwmgrApiBridge(this.bridge);
+    }
+    get incidents() {
+        assertConnection(this);
+        return new IncidentsApiBridge(this.bridge);
+    }
+    get mitre() {
+        assertConnection(this);
+        return new MitreApiBridge(this.bridge);
+    }
+    get plugins() {
+        assertConnection(this);
+        return new PluginsApiBridge(this.bridge);
+    }
+    get remoteResponse() {
+        assertConnection(this);
+        return new RemoteResponseApiBridge(this.bridge);
+    }
+    get workflows() {
+        assertConnection(this);
+        return new WorkflowsApiBridge(this.bridge);
+    }
+    get customobjects() {
+        assertConnection(this);
+        return new CustomobjectsApiBridge(this.bridge);
+    }
+    get faasGateway() {
+        assertConnection(this);
+        return new FaasGatewayApiBridge(this.bridge);
+    }
+    get loggingapi() {
+        assertConnection(this);
+        return new LoggingapiApiBridge(this.bridge);
     }
-  }
-
-  return getRandomValues(rnds8);
 }
-
-/**
- * Convert array of 16 byte values to UUID string format of the form:
- * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
- */
-
-const byteToHex = [];
-
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 0x100).toString(16).slice(1));
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "actors", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "alerts", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "detects", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "devices", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "fwmgr", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "incidents", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "mitre", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "plugins", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "remoteResponse", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "workflows", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "customobjects", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "faasGateway", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "loggingapi", null);
+
+class ApiIntegration {
+    falcon;
+    definition;
+    constructor(falcon, definition) {
+        this.falcon = falcon;
+        this.definition = definition;
+    }
+    async execute({ request } = {}) {
+        return this.falcon.plugins.postEntitiesExecuteV1({
+            resources: [
+                {
+                    definition_id: this.definition.definitionId,
+                    operation_id: this.definition.operationId,
+                    request,
+                },
+            ],
+        });
+    }
 }
 
-function unsafeStringify(arr, offset = 0) {
-  // Note: Be careful editing this code!  It's been tuned for performance
-  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+class CloudFunction {
+    falcon;
+    definition;
+    static GET = 'GET';
+    static POST = 'POST';
+    static PATCH = 'PATCH';
+    static DELETE = 'DELETE';
+    pollTimeout = 500;
+    intervalId;
+    constructor(falcon, definition) {
+        this.falcon = falcon;
+        this.definition = definition;
+    }
+    async execute({ path, method, queryParams, body, headers, }) {
+        const result = await this.falcon.faasGateway.postEntitiesExecutionV1({
+            function_id: this.definition.id,
+            function_version: this.definition.version,
+            payload: {
+                path,
+                method,
+                body,
+                headers,
+                query_params: queryParams,
+            },
+        });
+        return new Promise((resolve, reject) => {
+            const execution = result?.resources?.[0];
+            if (!execution?.execution_id) {
+                reject(result?.errors);
+            }
+            else {
+                this.pollForResult({
+                    resolve,
+                    reject,
+                    executionId: execution?.execution_id,
+                });
+            }
+        });
+    }
+    async getExecutionResult(executionId) {
+        const resultResponse = await this.falcon.faasGateway.getEntitiesExecutionV1({
+            id: executionId,
+        });
+        const executionResult = resultResponse?.resources?.[0];
+        return executionResult?.payload;
+    }
+    pollForResult({ resolve, reject, executionId, }) {
+        let exceptionRetries = 2;
+        this.intervalId = window.setInterval(async () => {
+            try {
+                const payload = await this.getExecutionResult(executionId);
+                if (payload) {
+                    window.clearInterval(this.intervalId);
+                    resolve(payload);
+                }
+            }
+            catch (e) {
+                if (exceptionRetries <= 0) {
+                    window.clearInterval(this.intervalId);
+                    reject(e);
+                }
+                exceptionRetries--;
+            }
+        }, this.pollTimeout);
+    }
+    path(pathEntry) {
+        const urlPath = new URL(pathEntry, 'http://localhost');
+        const path = urlPath.pathname;
+        const searchParams = [...urlPath.searchParams.entries()].map(([key, value]) => ({
+            [key]: [value],
+        }));
+        return {
+            path,
+            queryParams: searchParams,
+            get: async (queryParams = {}) => {
+                return this.get({
+                    path,
+                    queryParams: queryParams ?? searchParams ?? {},
+                });
+            },
+            post: async (body, queryParams = {}, headers = {}) => {
+                return this.post({
+                    path,
+                    queryParams: queryParams ?? searchParams ?? {},
+                    body,
+                    headers,
+                });
+            },
+            patch: async (body, queryParams = {}, headers = {}) => {
+                return this.post({
+                    path,
+                    queryParams: queryParams ?? searchParams ?? {},
+                    body,
+                    headers,
+                });
+            },
+            delete: async (body, queryParams = {}, headers = {}) => {
+                return this.post({
+                    path,
+                    queryParams: queryParams ?? searchParams ?? {},
+                    body,
+                    headers,
+                });
+            },
+        };
+    }
+    async get({ path, queryParams, headers }) {
+        return this.execute({
+            path,
+            method: CloudFunction.GET,
+            queryParams,
+            headers,
+        });
+    }
+    async post({ path, queryParams, body, headers }) {
+        return this.execute({
+            path,
+            method: CloudFunction.POST,
+            body,
+            queryParams,
+            headers,
+        });
+    }
+    async patch({ path, queryParams, body, headers }) {
+        return this.execute({
+            path,
+            method: CloudFunction.PATCH,
+            body,
+            queryParams,
+            headers,
+        });
+    }
+    async delete({ path, queryParams, body, headers }) {
+        return this.execute({
+            path,
+            method: CloudFunction.DELETE,
+            body,
+            queryParams,
+            headers,
+        });
+    }
+    destroy() {
+        if (this.intervalId) {
+            window.clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
 }
 
-const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-var native = {
-  randomUUID
-};
-
-function v4(options, buf, offset) {
-  if (native.randomUUID && !buf && !options) {
-    return native.randomUUID();
-  }
-
-  options = options || {};
-  const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-
-  rnds[6] = rnds[6] & 0x0f | 0x40;
-  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
-
-  if (buf) {
-    offset = offset || 0;
-
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
+class Collection {
+    falcon;
+    definition;
+    constructor(falcon, definition) {
+        this.falcon = falcon;
+        this.definition = definition;
+    }
+    async write(key, data) {
+        return this.falcon.bridge.postMessage({
+            type: 'collection',
+            payload: {
+                type: 'write',
+                key,
+                collection: this.definition.collection,
+                data,
+            },
+        });
+    }
+    async read(key) {
+        return this.falcon.bridge.postMessage({
+            type: 'collection',
+            payload: {
+                type: 'read',
+                key,
+                collection: this.definition.collection,
+            },
+        });
+    }
+    async delete(key) {
+        return this.falcon.bridge.postMessage({
+            type: 'collection',
+            payload: {
+                type: 'delete',
+                key,
+                collection: this.definition.collection,
+            },
+        });
+    }
+    async search({ startKey, endKey, limit }) {
+        return this.falcon.bridge.postMessage({
+            type: 'collection',
+            payload: {
+                type: 'search',
+                startKey,
+                endKey,
+                limit,
+                collection: this.definition.collection,
+            },
+        });
     }
-
-    return buf;
-  }
-
-  return unsafeStringify(rnds);
 }
 
-const VERSION = 'current';
-
-const CONNECTION_TIMEOUT = 5000;
-class Bridge {
-    onDataUpdate;
-    pendingMessages = new Map();
-    targetOrigin = '*';
-    constructor({ onDataUpdate } = {}) {
-        this.onDataUpdate = onDataUpdate;
-        window.addEventListener('message', this.handleMessage);
+class Logscale {
+    falcon;
+    constructor(falcon) {
+        this.falcon = falcon;
     }
-    destroy() {
-        window.removeEventListener('message', this.handleMessage);
+    async write(data, properties) {
+        return this.falcon.bridge.postMessage({
+            type: 'loggingapi',
+            payload: {
+                type: 'ingest',
+                data,
+                tag: properties?.tag,
+                tagSource: properties?.tagSource,
+                testData: properties?.testData,
+            },
+        });
     }
-    setOrigin(origin) {
-        this.targetOrigin = origin;
+    async query(data) {
+        return this.falcon.bridge.postMessage({
+            type: 'loggingapi',
+            payload: {
+                type: 'dynamic-execute',
+                data,
+            },
+        });
     }
-    async postMessage(message) {
-        return new Promise((resolve, reject) => {
-            const messageId = v4();
-            const timeoutTimer = setTimeout(() => {
-                reject(new Error(`Waiting for response from foundry host for "${message.type}" message (ID: ${messageId}) timed out after ${CONNECTION_TIMEOUT}ms`));
-            }, CONNECTION_TIMEOUT);
-            this.pendingMessages.set(messageId, (result) => {
-                clearTimeout(timeoutTimer);
-                resolve(result);
-            });
-            const eventData = {
-                message,
-                meta: {
-                    messageId,
-                    version: VERSION,
-                },
-            };
-            window.parent.postMessage(eventData, this.targetOrigin);
+}
+
+const ALLOWED_TARGETS = ['_self', '_blank'];
+class Navigation {
+    falcon;
+    constructor(falcon) {
+        this.falcon = falcon;
+    }
+    async navigateTo({ path, type, target, metaKey, ctrlKey, shiftKey, }) {
+        await this.falcon.bridge.postMessage({
+            type: 'navigateTo',
+            payload: {
+                path,
+                type: type ?? 'falcon',
+                target: target ?? '_self',
+                metaKey: metaKey ?? false,
+                ctrlKey: ctrlKey ?? false,
+                shiftKey: shiftKey ?? false,
+            },
         });
     }
-    handleMessage = (event) => {
-        if (!isValidResponse(event)) {
-            return;
+    async onClick(event, defaultTarget = '_self', defaultType = 'falcon') {
+        if (!(event instanceof Event)) {
+            throw Error('"event" property should be subclass of Event');
         }
-        const message = event.data.message;
-        if (message.type === 'data') {
-            this.onDataUpdate?.(message);
-            // data update events are unidirectional and originated from the host, so there cannot be a callback waiting for this message
+        if (!('preventDefault' in event)) {
             return;
         }
-        const { messageId } = event.data.meta;
-        const callback = this.pendingMessages.get(messageId);
-        if (!callback) {
-            throw new Error(`Received unexpected message`);
+        event.preventDefault();
+        if (!(event.target instanceof HTMLAnchorElement)) {
+            throw Error(`event target is not an anchor element, ${event.target}`);
         }
-        this.pendingMessages.delete(messageId);
-        callback(message.payload);
-    };
+        const path = event.target.getAttribute('href');
+        defaultTarget =
+            event.target.getAttribute('target') ??
+                defaultTarget;
+        const type = (event.target.dataset?.type ??
+            defaultType);
+        if (defaultTarget === null ||
+            !ALLOWED_TARGETS.includes(defaultTarget)) {
+            throw new Error('Target should be _self or _blank');
+        }
+        const target = defaultTarget;
+        if (path === undefined || path === null) {
+            throw new Error('Navigation path is missing. Make sure you have added navigation.onClick on the `a` tag and `href` is present.');
+        }
+        const { metaKey, ctrlKey, shiftKey } = event;
+        await this.navigateTo({ path, type, target, metaKey, ctrlKey, shiftKey });
+    }
+}
+
+class ResizeTracker {
+    bridge;
+    observer;
+    constructor(bridge) {
+        this.bridge = bridge;
+        this.observer = new ResizeObserver((entries) => this.handleResizeEvent(entries));
+        this.observer.observe(document.body);
+    }
+    handleResizeEvent(entries) {
+        const { height } = entries[0].contentRect;
+        this.bridge.sendUnidirectionalMessage({
+            type: 'resize',
+            payload: {
+                height,
+            },
+        });
+    }
+    destroy() {
+        this.observer.disconnect();
+    }
+}
+
+class UI {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    async openModal(extension, title, options = {}) {
+        const result = await this.bridge.postMessage({
+            type: 'openModal',
+            payload: {
+                extension,
+                title,
+                options,
+            },
+        });
+        if (result instanceof Error) {
+            throw result;
+        }
+        return result;
+    }
+    closeModal(payload) {
+        this.bridge.sendUnidirectionalMessage({
+            type: 'closeModal',
+            payload,
+        });
+    }
 }
 
 class FalconApi extends FalconPublicApis {
@@ -891,21 +2701,89 @@ class FalconApi extends FalconPublicApis {
     data;
     bridge = new Bridge({
         onDataUpdate: (data) => this.handleDataUpdate(data),
+        onBroadcast: (msg) => this.handleBroadcastMessage(msg),
+        onLivereload: () => this.handleLivereloadMessage(),
     });
+    ui = new UI(this.bridge);
+    resizeTracker;
+    cloudFunctions = [];
+    apiIntegrations = [];
+    collections = [];
     async connect() {
         const { origin, data } = await this.bridge.postMessage({ type: 'connect' });
         this.bridge.setOrigin(origin);
         this.data = data;
+        this.updateTheme(data?.theme);
+        this.resizeTracker = new ResizeTracker(this.bridge);
         this.isConnected = true;
     }
+    sendBroadcast(payload) {
+        this.bridge.sendUnidirectionalMessage({ type: 'broadcast', payload });
+    }
+    async uploadFile(fileUploadType, initialData) {
+        return this.bridge.postMessage({
+            type: 'fileUpload',
+            fileUploadType,
+            payload: initialData,
+        });
+    }
     handleDataUpdate(dataMessage) {
         this.data = dataMessage.payload;
+        this.updateTheme(this.data.theme);
         this.events.emit('data', this.data);
     }
+    handleBroadcastMessage(message) {
+        this.events.emit('broadcast', message.payload);
+    }
+    handleLivereloadMessage() {
+        document.location.reload();
+    }
+    updateTheme(activeTheme) {
+        if (!activeTheme) {
+            return;
+        }
+        const inactiveTheme = activeTheme === 'theme-dark' ? 'theme-light' : 'theme-dark';
+        document.documentElement.classList.add(activeTheme);
+        document.documentElement.classList.remove(inactiveTheme);
+    }
+    cloudFunction({ id, version }) {
+        assertConnection(this);
+        const cf = new CloudFunction(this, { id, version });
+        this.cloudFunctions.push(cf);
+        return cf;
+    }
+    apiIntegration({ definitionId, operationId }) {
+        assertConnection(this);
+        const cf = new ApiIntegration(this, { operationId, definitionId });
+        this.apiIntegrations.push(cf);
+        return cf;
+    }
+    collection({ collection }) {
+        assertConnection(this);
+        const co = new Collection(this, { collection });
+        this.collections.push(co);
+        return co;
+    }
+    get navigation() {
+        assertConnection(this);
+        return new Navigation(this);
+    }
+    get logscale() {
+        assertConnection(this);
+        return new Logscale(this);
+    }
     destroy() {
+        this.cloudFunctions.forEach((cf) => cf.destroy());
+        this.resizeTracker?.destroy();
         this.bridge.destroy();
     }
 }
+__decorate([
+    Memoize()
+], FalconApi.prototype, "navigation", null);
+__decorate([
+    Memoize()
+], FalconApi.prototype, "logscale", null);
 
-export { FalconApi as default };
+export { Bridge, FalconApi as default };
 //# sourceMappingURL=index.js.map