fiftyone.devicedetection.onpremise 4.4.137 → 4.4.139

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fiftyone.devicedetection.onpremise",
-  "version": "4.4.137",
+  "version": "4.4.139",
   "description": "Device detection on-premise services for the 51Degrees Pipeline API",
   "keywords": [
     "51degrees",
@@ -54,6 +54,6 @@
   "files": [
     "build",
     "*.js",
-    "*.ts"
+    "types"
   ]
 }

package/types/component.d.ts

@@ -0,0 +1,28 @@
+export = Component;
+declare class Component {
+    /**
+     *  Constructor for Component
+     *
+     * @param {object} metadata Metadata
+     * @param {object} engineMetadata Engine metadata
+     */
+    constructor(metadata: object, engineMetadata: object);
+    metadata: object;
+    engineMetadata: object;
+    /**
+     * @type {string}
+     */
+    name: string;
+    /**
+     * @type {object}
+     */
+    properties: object;
+    /**
+     * Yield component properties
+     *
+     * @generator
+     * @yields {Property}
+     * @returns {void}
+     */
+    getProperties(): void;
+}

package/types/constants.d.ts

@@ -0,0 +1,12 @@
+export let dataUpdateUrl: string;
+export let deviceIdDescription: string;
+export let userAgentsDescription: string;
+export let differenceDescription: string;
+export let methodDescription: string;
+export let matchedNodesDescription: string;
+export let driftDescription: string;
+export let iterationsDescription: string;
+export let none: string;
+export let performance: string;
+export let combined: string;
+export let predictive: string;

package/types/dataFileMissingPropertyService.d.ts

@@ -0,0 +1,26 @@
+export = DeviceDetectionMissingPropertyService;
+declare const DeviceDetectionMissingPropertyService_base: typeof import("fiftyone.pipeline.engines/types/missingPropertyService");
+/**
+ * @typedef {import('fiftyone.pipeline.core').FlowElement} FlowElement
+ */
+/**
+ * Instance of the MissingPropertyService class that checks if a
+ * property is available in the current dataFile
+ */
+declare class DeviceDetectionMissingPropertyService extends DeviceDetectionMissingPropertyService_base {
+    /**
+     * Constructor for Missing Property Service that receives a requested property
+     * key that is missing in the data. If it is missing because the data does not
+     * exist in the data file that was chosen, it returns an error which
+     * states which data file the property can be found in.
+     *
+     * @param {string} key missing property key
+     * @param {FlowElement} flowElement the FlowElement the key was missing from
+     * @returns {never} throws an error
+     */
+    check(key: string, flowElement: FlowElement): never;
+}
+declare namespace DeviceDetectionMissingPropertyService {
+    export { FlowElement };
+}
+type FlowElement = import("fiftyone.pipeline.core/types/flowElement");

package/types/deviceDetectionDataFile.d.ts

@@ -0,0 +1,21 @@
+export = DeviceDetectionDataFile;
+declare const DeviceDetectionDataFile_base: typeof import("fiftyone.pipeline.engines/types/dataFile");
+/**
+ * Instance of DataFile class for the Device Detection Engine
+ * Extends datafile by providing a formatter for the DataFileUpdateService
+ * update url which contains the product, type and licensekeys.
+ * These paramaters are passed in to the datafile constructor's
+ * updateURLParams parameter
+ **/
+declare class DeviceDetectionDataFile extends DeviceDetectionDataFile_base {
+    /**
+     * Constructor for Device Detection DataFile
+     *
+     * @param {object} options options for the datafile
+     * @param {string} options.useUrlFormatter whether to append default URL params for Data File download
+     **/
+    constructor({ useUrlFormatter, ...rest }: {
+        useUrlFormatter: string;
+    });
+    useUrlFormatter: string;
+}

package/types/deviceDetectionOnPremise.d.ts

@@ -0,0 +1,121 @@
+export = DeviceDetectionOnPremise;
+declare const DeviceDetectionOnPremise_base: typeof import("fiftyone.pipeline.engines/types/engine");
+/**
+ * On premise version of the 51Degrees Device Detection Engine
+ * Uses a data file to process evidence in FlowData and create results
+ * This datafile can automatically update when a new version is available
+ **/
+declare class DeviceDetectionOnPremise extends DeviceDetectionOnPremise_base {
+    /**
+     * Constructor for Device Detection On Premise engine
+     *
+     * @param {object} options options for the engine
+     * @param {string} options.dataFilePath path to the datafile
+     * @param {boolean} options.autoUpdate whether the datafile
+     * should be registered with the data file update service
+     * @param {number} options.pollingInterval How often to poll for
+     * updates to the datafile (minutes)
+     * @param {number} options.updateTimeMaximumRandomisation
+     * Maximum randomisation offset in seconds to polling time interval
+     * @param {DataKeyedCache} options.cache an instance of the Cache class from
+     * Fiftyone.Pipeline.Engines. NOTE: This is no longer supported for
+     * on-premise engine.
+     * @param {string} options.dataUpdateUrl base url for the datafile
+     * update service
+     * @param {boolean} options.dataUpdateVerifyMd5 whether to check MD5 of datafile
+     * @param {boolean} options.dataUpdateUseUrlFormatter whether to append default URL params for Data File download
+     * @param {Array<string>} options.restrictedProperties list of properties the engine
+     * will be restricted to
+     * @param {string} options.licenceKeys license key(s) used by the
+     * data file update service. A key can be obtained from the
+     * 51Degrees website: https://51degrees.com/pricing.
+     * If you do not wish to use a key then you can specify
+     * an empty string, but this will cause automatic updates to
+     * be disabled.
+     * @param {boolean} options.download whether to download the datafile
+     * or store it in memory
+     * @param {string} options.performanceProfile options are:
+     * LowMemory, MaxPerformance, Balanced, BalancedTemp, HighPerformance
+     * @param {boolean} options.fileSystemWatcher whether to monitor the datafile
+     * path for changes
+     * @param {number} options.concurrency defaults to the number of cpus
+     * in the machine
+     * @param {boolean} options.reuseTempFile Indicates that an existing temp
+     * file may be used. This should be selected if multiple instances wish to
+     * use the same file to prevent high disk usage.
+     * @param {boolean} options.updateMatchedUserAgent True if the detection
+     * should record the matched characters from the target User-Agent
+     * @param {number} options.maxMatchedUserAgentLength Number of characters to
+     * consider in the matched User-Agent. Ignored if updateMatchedUserAgent
+     * is false
+     * @param {number} options.drift Set maximum drift in hash position to
+     * allow when processing HTTP headers.
+     * @param {number} options.difference Set the maximum difference to allow
+     * when processing HTTP headers. The difference is the difference
+     * in hash value between the hash that was found, and the hash
+     * that is being searched for. By default this is 0.
+     * @param {boolean} options.allowUnmatched True if there should be at least
+     * one matched node in order for the results to be
+     * considered valid. By default, this is false
+     * @param {boolean} options.createTempDataCopy If true, the engine will
+     * create a copy of the data file in a temporary location
+     * rather than using the file provided directly. If not
+     * loading all data into memory, this is required for
+     * automatic data updates to occur.
+     * @param {string} options.tempDataDir The directory to use for the
+     * temporary data copy if 'createTempDataCopy' is set to true.
+     * @param {boolean} options.updateOnStart whether to download / update
+     * the datafile on initialisation
+     */
+    constructor({ dataFilePath, autoUpdate, cache, dataUpdateUrl, dataUpdateVerifyMd5, dataUpdateUseUrlFormatter, restrictedProperties, licenceKeys, download, performanceProfile, reuseTempFile, updateMatchedUserAgent, maxMatchedUserAgentLength, drift, difference, concurrency, allowUnmatched, fileSystemWatcher, pollingInterval, updateTimeMaximumRandomisation, createTempDataCopy, tempDataDir, updateOnStart }: {
+        dataFilePath: string;
+        autoUpdate: boolean;
+        pollingInterval: number;
+        updateTimeMaximumRandomisation: number;
+        cache: DataKeyedCache;
+        dataUpdateUrl: string;
+        dataUpdateVerifyMd5: boolean;
+        dataUpdateUseUrlFormatter: boolean;
+        restrictedProperties: Array<string>;
+        licenceKeys: string;
+        download: boolean;
+        performanceProfile: string;
+        fileSystemWatcher: boolean;
+        concurrency: number;
+        reuseTempFile: boolean;
+        updateMatchedUserAgent: boolean;
+        maxMatchedUserAgentLength: number;
+        drift: number;
+        difference: number;
+        allowUnmatched: boolean;
+        createTempDataCopy: boolean;
+        tempDataDir: string;
+        updateOnStart: boolean;
+    }, ...args: any[]);
+    /**
+     * Function for initialising the engine, wrapped like this so
+     * that an engine can be initialised once the datafile is
+     * retrieved if updateOnStart is set to true
+     *
+     * @returns {void}
+     */
+    initEngine: () => void;
+    profiles(): Generator<Profile, void, unknown>;
+    /**
+     * Internal process method for Device Detection On Premise engine
+     * Fetches the results from the SWIG wrapper into an instance of
+     * the SwigData class which can be used to retrieve results from
+     * the FlowData.
+     *
+     * @param {FlowData} flowData FlowData to process
+     * @returns {Promise<void>} the result of processing
+     **/
+    processInternal(flowData: FlowData): Promise<void>;
+}
+declare namespace DeviceDetectionOnPremise {
+    export { DataKeyedCache, Engine, FlowData };
+}
+import Profile = require("./profile");
+type DataKeyedCache = import("fiftyone.pipeline.engines/types/dataKeyedCache");
+type Engine = import("fiftyone.pipeline.engines/types/engine");
+type FlowData = import("fiftyone.pipeline.core/types/flowData");

package/types/deviceDetectionOnPremisePipelineBuilder.d.ts

@@ -0,0 +1,105 @@
+export = DeviceDetectionOnPremisePipelineBuilder;
+declare const DeviceDetectionOnPremisePipelineBuilder_base: typeof import("fiftyone.pipeline.core/types/pipelineBuilder");
+/**
+ * @typedef {import('fiftyone.pipeline.engines').DataFileUpdateService} DataFileUpdateService
+ */
+declare class DeviceDetectionOnPremisePipelineBuilder extends DeviceDetectionOnPremisePipelineBuilder_base {
+    /**
+     * Extension of pipelineBuilder class that allows for the quick
+     * generation of a device detection pipeline. Adds share usage,
+     * caching and toggles between on premise and cloud with
+     * simple paramater changes
+     *
+     * @param {object} options the options for the pipeline builder
+     * @param {string} [options.licenceKeys] license key(s) used by the
+     * data file update service. A key can be obtained from the
+     * 51Degrees website: https://51degrees.com/pricing.
+     * This parameter MUST be set when using a data file.
+     * If you do not wish to use a key then you can specify
+     * an empty string, but this will cause automatic updates
+     * to be disabled.
+     * @param {string} options.dataFile dataFile path for the on premise engine
+     * @param {boolean} [options.dataUpdateVerifyMd5] whether to check MD5 of datafile
+     * @param {boolean} [options.dataUpdateUseUrlFormatter] whether to append default URL params for Data File download
+     * @param {boolean} [options.autoUpdate] whether to autoUpdate the dataFile
+     * @param {string} [options.dataUpdateUrl] base url for the datafile
+     * @param {number} [options.pollingInterval] How often to poll for
+     * updates to the datafile (minutes)
+     * @param {number} [options.updateTimeMaximumRandomisation]
+     * Maximum randomisation offset in seconds to polling time interval
+     * @param {boolean} [options.shareUsage] whether to include the share
+     * usage element
+     * @param {boolean} [options.fileSystemWatcher] whether to monitor the datafile
+     * path for changes
+     * @param {boolean} [options.updateOnStart] whether to download / update a
+     * dataFile to the path specified in options.dataFile on start
+     * @param {number} [options.cacheSize] size of the default cache
+     * (includes cache if set). NOTE: This is not supported for on-premise
+     * engine.
+     * @param {Array<string>} [options.restrictedProperties] list of properties the engine
+     * will be restricted to
+     * @param {string} [options.performanceProfile] used to control the tradeoff
+     * between performance and system memory usage (Only applies to on-premise,
+     * not cloud) options are: LowMemory, MaxPerformance, Balanced,
+     * BalancedTemp, HighPerformance
+     * @param {number} [options.concurrency] defaults to the number of cpus
+     * in the machine
+     * @param {boolean} [options.updateMatchedUserAgent] True if the detection
+     * should record the matched characters from the target User-Agent
+     * @param {number} [options.maxMatchedUserAgentLength] Number of characters to
+     * consider in the matched User-Agent. Ignored if updateMatchedUserAgent is
+     * false
+     * @param {number} [options.drift] Set maximum drift in hash position to allow
+     * when processing HTTP headers.
+     * @param {number} [options.difference] Set the maximum difference to allow
+     * when processing HTTP headers. The difference is the difference in hash
+     * value between the hash that was found, and the hash that is being searched
+     * for. By default this is 0.
+     * @param {string} [options.allowUnmatched] If set to false, a non-matching
+     * User-Agent will result in properties without set values.
+     * If set to true, a non-matching User-Agent will cause the 'default profiles'
+     * to be returned.
+     * This means that properties will always have values
+     * (i.e. no need to check .HasValue) but some may be inaccurate.
+     * By default, this is false.
+     * @param {boolean} [options.createTempDataCopy] If true, the engine will
+     * create a copy of the data file in a temporary location
+     * rather than using the file provided directly. If not
+     * loading all data into memory, this is required for
+     * automatic data updates to occur.
+     * @param {string} [options.tempDataDir] The directory to use for the
+     * temporary data copy if 'createTempDataCopy' is set to true.
+     * @param {DataFileUpdateService} [options.dataFileUpdateService] Set
+     * DataFileUpdateService so the datafiles can receive
+     * automatic updates
+     */
+    constructor({ dataFileUpdateService, licenceKeys, dataFile, dataUpdateVerifyMd5, dataUpdateUseUrlFormatter, autoUpdate, dataUpdateUrl, pollingInterval, updateTimeMaximumRandomisation, shareUsage, fileSystemWatcher, updateOnStart, cacheSize, restrictedProperties, performanceProfile, concurrency, updateMatchedUserAgent, maxMatchedUserAgentLength, drift, difference, allowUnmatched, createTempDataCopy, tempDataDir }: {
+        licenceKeys?: string;
+        dataFile: string;
+        dataUpdateVerifyMd5?: boolean;
+        dataUpdateUseUrlFormatter?: boolean;
+        autoUpdate?: boolean;
+        dataUpdateUrl?: string;
+        pollingInterval?: number;
+        updateTimeMaximumRandomisation?: number;
+        shareUsage?: boolean;
+        fileSystemWatcher?: boolean;
+        updateOnStart?: boolean;
+        cacheSize?: number;
+        restrictedProperties?: Array<string>;
+        performanceProfile?: string;
+        concurrency?: number;
+        updateMatchedUserAgent?: boolean;
+        maxMatchedUserAgentLength?: number;
+        drift?: number;
+        difference?: number;
+        allowUnmatched?: string;
+        createTempDataCopy?: boolean;
+        tempDataDir?: string;
+        dataFileUpdateService?: DataFileUpdateService;
+    }, ...args: any[]);
+}
+declare namespace DeviceDetectionOnPremisePipelineBuilder {
+    export { DataFileUpdateService };
+}
+type DataFileUpdateService = import("fiftyone.pipeline.engines/types/dataFileUpdateService");

package/types/index.d.ts

@@ -0,0 +1,7 @@
+export let DeviceDetectionOnPremise: typeof import("./deviceDetectionOnPremise");
+export let DeviceDetectionOnPremisePipelineBuilder: typeof import("./deviceDetectionOnPremisePipelineBuilder");
+export let SwigData: typeof import("./swigData");
+export let swigHelpers: {
+    vectorToArray: (vector: object) => any[];
+    swigDateToDate: (swigDate: object) => Date;
+};

package/types/profile.d.ts

@@ -0,0 +1,20 @@
+export = Profile;
+declare class Profile {
+    /**
+     *  Constructor for Profile
+     *
+     * @param {object} metadata Metadata
+     * @param {object} engineMetadata Engine metadata
+     */
+    constructor(metadata: object, engineMetadata: object);
+    metadata: object;
+    engineMetadata: object;
+    /**
+     * @type {Component}
+     */
+    component: import("./component");
+    /**
+     * @type {number} uint32
+     */
+    profileId: number;
+}

package/types/property.d.ts

@@ -0,0 +1,54 @@
+export = Property;
+declare class Property {
+    /**
+     *  Constructor for Property
+     *
+     * @param {object} metadata Metadata
+     * @param {object} engineMetadata Engine metadata
+     */
+    constructor(metadata: object, engineMetadata: object);
+    metadata: object;
+    engineMetadata: object;
+    /**
+     * @type {string}
+     */
+    name: string;
+    /**
+     * @type {string}
+     */
+    type: string;
+    /**
+     * @type {Array<string>}
+     */
+    dataFiles: Array<string>;
+    /**
+     * @type {string}
+     */
+    category: string;
+    /**
+     * @type {string}
+     */
+    description: string;
+    /**
+     * @type {Component}
+     */
+    component: import("./component");
+    /**
+     * @type {object}
+     */
+    values: object;
+    /**
+     * Yield property values
+     *
+     * @generator
+     * @yields {object}
+     * @returns {void}
+     */
+    getValues(): void;
+    /**
+     * Get number of values in the property
+     *
+     * @returns {number} uint32
+     */
+    getNumberOfValues(): number;
+}

package/types/swigData.d.ts

@@ -0,0 +1,38 @@
+export = SwigData;
+declare const SwigData_base: typeof import("fiftyone.pipeline.engines/types/aspectData");
+/**
+ * @typedef {import('fiftyone.pipeline.core').FlowElement} FlowElement
+ */
+/**
+ * Extension of aspectData which stores the results created by the SWIG wrapper
+ */
+declare class SwigData extends SwigData_base {
+    /**
+     * Constructor for SwigData
+     *
+     * @param {object} options options object
+     * @param {FlowElement} options.flowElement the FlowElement the
+     * data is part of
+     * @param {object} options.swigResults the results from the
+     * swig engine
+     */
+    constructor({ flowElement, swigResults }: {
+        flowElement: FlowElement;
+        swigResults: object;
+    }, ...args: any[]);
+    swigResults: object;
+    missingPropertyService: DataFileMissingPropertyService;
+    /**
+     * Retrieves elementData via the swigWrapper but also casts it to the
+     * correct type via a check of the engine's property list metadata
+     *
+     * @param {string} key the property key to retrieve
+     * @returns {AspectPropertyValue} value property value
+     */
+    getInternal(key: string): typeof import("fiftyone.pipeline.core/types/aspectPropertyValue");
+}
+declare namespace SwigData {
+    export { FlowElement };
+}
+import DataFileMissingPropertyService = require("./dataFileMissingPropertyService");
+type FlowElement = import("fiftyone.pipeline.core/types/flowElement");

package/types/swigHelpers.d.ts

@@ -0,0 +1,2 @@
+export function vectorToArray(vector: object): any[];
+export function swigDateToDate(swigDate: object): Date;