deepar 4.1.0 → 5.0.0-alpha-1

package/js/types/DeepAR.d.ts

@@ -0,0 +1,293 @@
+import { ARTouchInfo } from "./touchType";
+import { DeepARCallbacks } from "./callbacks";
+import { DeepARParams } from "./initParams";
+import { LogType } from "./logType";
+/**
+ * Initialize the DeepAR SDK.<br><br>
+ * @param params Initialization parameters.
+ * @example
+ * import * as deepar from 'deepar';
+ *
+ * let deepAR = deepar.initialize({
+ *   licenseKey: 'your_license_key_here',
+ *   canvas: document.getElementById('deepar-canvas')
+ * });
+ */
+export declare function initialize(params: DeepARParams): Promise<DeepAR>;
+/**
+ * Main class for interacting with DeepAR SDK. To get a DeepAR object call {@link initialize}.
+ */
+export declare class DeepAR {
+    /**
+     * Emscripten module object. Contains all the exposed C/C++ API. Used for interacting with the native SDK.
+     * @private
+     */
+    private module;
+    /**
+     * Callbacks property is used to add/remove/change callbacks called by the DeepAR SDK. See list of all callbacks at {@link DeepARCallbacks}. <br><br>
+     * Example: To add/change certain callback:
+     * ```javascript
+     * let deepAR = deepar.initialize({...});
+     * deepAR.callbacks.onFaceVisibilityChanged = () => {
+     *     // do something
+     * };
+     * ```
+     *
+     * To remove certain callback:
+     * ```javascript
+     * deepAR.callbacks.onFaceTracked = undefined;
+     * ```
+     */
+    callbacks: DeepARCallbacks;
+    /**
+     * @internal
+     * @param module
+     */
+    constructor(module: any);
+    /**
+     * Switch the AR effect for preview.
+     *
+     * @param effect A path (URL) to the AR effect file or an ArrayBuffer object of an already fetched AR effect file.
+     * @param effectOptions Effect options.
+     * @param effectOptions.slot Default value is "mask" if slot is not given. Slot is a container for a given AR effect. When replacing the already loaded AR effect, call switchEffect with that same slot. To remove AR effect entirely, call {@link clearEffect} with the same slot.
+     * @param effectOptions.face If AR effect is face filter, select to which face to attach it to. The value should be between 0 and 3. Default value is 0.
+     *
+     *
+     * @example
+     * // Switch filter 1.
+     * deepAR.switchEffect('url/path/to/filter1');
+     * // Later switch fo filter 2.
+     * deepAR.switchEffect('url/path/to/filter2');
+     *
+     * // Remove the current filter.
+     * deepAR.clearEffect();
+     *
+     * // Put two filters at the same time.
+     * deepAR.switchEffect('url/path/to/backgroundReplacement', {slot: 'background'});
+     * deepAR.switchEffect('url/path/to/glasses', {slot: 'faceMask'});
+     * // Replace the glasses filter.
+     * deepAR.switchEffect('url/path/to/glasses2', {slot: 'faceMask'});
+     * // Remove those filters.
+     * deepAR.clearEffect('background');
+     * deepAR.clearEffect('faceMask');
+     */
+    switchEffect(effect: string | ArrayBuffer, effectOptions?: {
+        slot?: string;
+        face?: number;
+    }): Promise<void>;
+    /**
+     * Clears the given slot of any loaded effects.
+     * @param slot The effect slot name.
+     */
+    clearEffect(slot?: string): void;
+    /**
+     * Captures a screenshot of the current screen.
+     * @returns <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs">Data URL</a> promise containing the image in <code>data:image/png</code> format.
+     */
+    takeScreenshot(): Promise<string>;
+    /**
+     * Starts video recording of the canvas.
+     * @param options Parameters that specify the format of recorded videos
+     * @param options.mimeType A MIME type specifying the format for the resulting video, such as `video/webm` or `video/mp4`. Corresponds to the MIME type used by <a href="https://developer.mozilla.org/en-US/docs/Web/API/Blob">Blob</a>objects and <a href="https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder">MediaRecorder</a>from the MediaStream Recording API. Note that `video/mp4` may not be supported in all browsers.
+     */
+    startVideoRecording(options?: {
+        mimeType?: string;
+    }): void;
+    /**
+     * Stops the video recording and returns a video blob.
+     * @returns A promise resolving to Blob of a video.
+     */
+    finishVideoRecording(): Promise<Blob>;
+    /**
+     * Starts the camera preview. By default, the camera will be user facing.
+     * @param mirror Mirror the camera horizontally.
+     * @param mediaStreamConstraints Options passed to MediaDevices.getUserMedia(). The default is the user facing camera.
+     */
+    startCamera(mirror?: boolean, mediaStreamConstraints?: MediaStreamConstraints): void;
+    /**
+     * Stops the camera preview or custom video preview set by {@link setVideoElement}.
+     */
+    stopVideo(): void;
+    /**
+     * Used to pass the HTMLVideoElement to the DeepAR SDK. The SDK will use this video as camera source. This method should be used instead of {@link DeepAR.startCamera} when you want to handle getUserMedia outside the SDK or you need to apply the masks to any video stream.
+     * To disable automatic camera preview by DeepAR:
+     * ```js
+     * const deepAR = deepar.initialize({
+     *     // ...
+     *     additionalOptions: {
+     *         cameraConfig: {
+     *             disableDefaultCamera: true
+     *         }
+     *     }
+     * });
+     * ```
+     * @param videoElement Video element.
+     * @param mirror Mirror the video horizontally.
+     */
+    setVideoElement(videoElement: HTMLVideoElement, mirror: boolean): void;
+    /**
+     * Shutdown the DeepAR SDK and release all resources associated with it. It is invalid to call any function from this {@link DeepAR} object after shutdown.
+     * After shutdown call, it is possible to call {@link initialize} again.
+     */
+    shutdown(): void;
+    /**
+     * Process RGBA image. Used for processing single image. Can be used instead of {@link startCamera} or {@link setVideoElement}.
+     * @param frame Image.
+     * @param width Width of the image.
+     * @param height Height of the image.
+     * @param mirror Mirror frame horizontally.
+     */
+    processFrame(frame: Uint8Array, width: number, height: number, mirror: boolean): void;
+    /**
+     * If you want to apply DeepAR processing on a single image instead of a camera stream use this method. Can be used instead of {@link startCamera} or {@link DeepAR.setVideoElement}. See example usage <a href="https://github.com/DeepARSDK/photoedit-web-js">here</a>.
+     * @param image
+     */
+    processImage(image: HTMLImageElement): void;
+    /**
+     * Pauses the DeepAR processing and rendering on canvas.
+     * @param isPause If true, DeepAR will pause. Otherwise, it will resume processing and rendering.
+     */
+    pause(isPause: boolean): void;
+    /**
+     * Changes a node or component bool parameter of the currently loaded effect. For more details about changeParameter API read our docs <a href="https://docs.deepar.ai/guides-and-tutorials/changing-filter-parameters-from-code">here</a>.
+     * @param gameObject The name of the node from DeepAR Studio. If multiple nodes share the same name, only the first one will be affected.
+     * @param component The name of the component. If the name of the component is null or an empty string, the node itself will be affected.
+     * @param parameter The name of the parameter.
+     * @param value New parameter value.
+     */
+    changeParameterFloat(gameObject: string, component: string, parameter: string, value: number): void;
+    /**
+     * Changes a node or component float parameter of the currently loaded effect. For more details about changeParameter API read our docs <a href="https://docs.deepar.ai/guides-and-tutorials/changing-filter-parameters-from-code">here</a>.
+     * @param gameObject The name of the node from DeepAR Studio. If multiple nodes share the same name, only the first one will be affected.
+     * @param component The name of the component. If the name of the component is null or an empty string, the node itself will be affected.
+     * @param parameter The name of the parameter.
+     * @param value New parameter value.
+     */
+    changeParameterBool(gameObject: string, component: string, parameter: string, value: boolean): void;
+    /**
+     * Changes a node or component vector parameter of the currently loaded effect. For more details about changeParameter API read our docs <a href="https://docs.deepar.ai/guides-and-tutorials/changing-filter-parameters-from-code">here</a>.
+     * @param gameObject The name of the node from DeepAR Studio. If multiple nodes share the same name, only the first one will be affected.
+     * @param component The name of the component. If the name of the component is null or an empty string, the node itself will be affected.
+     * @param parameter The name of the parameter.
+     * @param x X component of the new parameter vector.
+     * @param y Y component of the new parameter vector.
+     * @param z Z component of the new parameter vector.
+     * @param w W component of the new parameter vector.
+     */
+    changeParameterVector(gameObject: string, component: string, parameter: string, x: number, y: number, z: number, w: number): void;
+    /**
+     * Changes a node or component texture parameter of the currently loaded effect. For more details about changeParameter API read our docs <a href="https://docs.deepar.ai/guides-and-tutorials/changing-filter-parameters-from-code">here</a>.
+     * @param gameObject The name of the node from DeepAR Studio. If multiple nodes share the same name, only the first one will be affected.
+     * @param component The name of the component. If the name of the component is null or an empty string, the node itself will be affected.
+     * @param parameter The name of the parameter.
+     * @param textureUrl Url of the image that is going to be used as texture.
+     */
+    changeParameterTexture(gameObject: string, component: string, parameter: string, textureUrl: string): void;
+    /**
+     * This method allows the user to fire a custom animation trigger for model animations from code. To fire a custom trigger,
+     * the trigger string must match the custom trigger set in the Studio when creating the effect. Read more <a href="https://help.deepar.ai/en/articles/4354740-animations-tutorial-fbx-model-animations">here</a>.
+     * @param trigger The name of the trigger.
+     */
+    fireTrigger(trigger: string): void;
+    /**
+     * Informs DeepAR that the specified touch event occurred.
+     * @param touchInfo Touch event information.
+     */
+    touchOccurred(touchInfo: ARTouchInfo): void;
+    /**
+     * Change face detection sensitivity
+     * @param sensitivity 0 .. 5 (0 is fast, 4,5 is slow but allows to find smaller faces)
+     */
+    setFaceDetectionSensitivity(sensitivity: number): void;
+    /**
+     * Enable/disable forced rendering on the canvas. It is useful to enable offscreen rendering in scenarios when the browser
+     * does not call requestAnimationFrame() function. DeepAR internally uses requestAnimationFrame() for the rendering loop.
+     * For example, when the browser tab is not focused, the browser will not call requestAnimationFrame() and DeepAR will not
+     * render. If offscreen rendering is enabled, DeepAR will use its internal timer for the rendering loop. Note that offscreen
+     * rendering enabled will not have as good results in terms of FPS compared to offscreen rendering disabled. <br><br>
+     *
+     * If you need to use offscreen rendering. The best practice is to enable it only when needed - like when the browser tab is not focused.
+     * Otherwise, it is best to always disable offscreen rendering.
+     * @param enable True - DeepAR will use its internal timer for the rendering loop. Rendering will work even when tab is not focused. False - DeepAR will use requestAnimationFrame() for the rendering loop.
+     */
+    setOffscreenRenderingEnabled(enable: boolean): void;
+    /**
+     * Set the FPS of DeepAR rendering.
+     * @param fps New FPS.
+     */
+    setFps(fps: number): void;
+    /**
+     * Initialize foot tracking.<br><br>
+     *
+     * Foot tracking is usually lazy loaded on demand when filter loaded  with {@link switchEffect} requires it.
+     * But this method will start loading the foot tracking immediately.
+     * To start initializing foot tracking as soon as possible pass "foot" hint in the {@link initialize} function (see {@link DeepARParams}). <br><br>
+     *
+     * If the foot tracking is already initialized it will do nothing.
+     * To check if foot tracking is initialized call {@link isFootTrackingInitialized} or wait {@link DeepARCallbacks.onFootTrackingInitialized} callback.
+     */
+    initializeFootTracking(): void;
+    /**
+     * Check weather the foot tracking is initialized.
+     */
+    isFootTrackingInitialized(): boolean;
+    /**
+     * Initialize segmentation.<br><br>
+     *
+     * Segmentation is usually lazy loaded on demand when filter loaded  with {@link switchEffect} requires it.
+     * But this method will start loading the segmentation immediately.
+     * To start initializing foot tracking as soon as possible pass "segmentation" hint in the {@link initialize} function (see {@link DeepARParams}). <br><br>
+     *
+     * If the segmentation is already initialized it will do nothing.
+     * To check if segmentation is initialized call {@link isSegmentationInitialized} or wait {@link DeepARCallbacks.onSegmentationInitialized} callback.
+     */
+    initializeSegmentation(): void;
+    /**
+     * Check weather the segmentation is initialized.
+     */
+    isSegmentationInitialized(): boolean;
+    /**
+     * Display profiling metrics on preview.
+     * @param enabled
+     */
+    showStats(enabled: boolean): void;
+    /**
+     * Enable or disable global physics simulation.
+     * @param enabled
+     */
+    simulatePhysics(enabled: boolean): void;
+    /**
+     * Moves the selected game object from its current position in a tree and sets it as a direct child of a target game object.
+     * This is equivalent to moving around a node in the node hierarchy in the DeepAR Studio.
+     * @param selectedGameObject Node to move.
+     * @param targetGameObject New node parent.
+     */
+    moveGameObject(selectedGameObject: string, targetGameObject: string): void;
+    /** INTERNAL API **/
+    /**
+     * @internal
+     * @param enable
+     */
+    enableAutoframing(enable: boolean): void;
+    /**
+     * @internal
+     * Returns all the messages pushed to the console log buffer and empties
+     * the buffer.
+     * @returns All the messages from console log buffer.
+     */
+    getConsoleLogs(): any;
+    /**
+     * @internal
+     * Pushes message to the console log buffer.
+     * @param message Message to be pushed to the console log buffer.
+     * @param logType Logging type.
+     * @returns true if the message was successfully pushed, false otherwise
+     */
+    pushConsoleLog(message: string, logType: LogType): boolean;
+    /**
+     * @internal
+     * Display physics colliders preview on screen.
+     * @param enabled
+     */
+    showColliders(enabled: boolean): void;
+}

package/js/types/callbacks.d.ts

@@ -0,0 +1,42 @@
+import { FaceData } from "./faceData";
+import { FootData } from "./footData";
+/**
+ * Callbacks from DeepAR notifying events.
+ * Register callbacks with {@link DeepAR.callbacks}.
+ */
+export interface DeepARCallbacks {
+    /**
+     * Called whenever the face enters or exits the camera field of view. <br>
+     * NOTE: This callback is only called when the SDK does face tracking. For example, you laded some effect that uses face tracking (most of them do). But if no effect is loaded this callback will not get called because the SDK is not performing face tracking.
+     * @param visible True if the face is visible on the camera, false otherwise.
+     */
+    onFaceVisibilityChanged?: (visible: boolean) => void;
+    /**
+     * Passes the information about the detected faces. If this callback is set, it will get called every frame when a face is detected.
+     * @param faceDataArray Information about all the tracked faces.
+     */
+    onFaceTracked?: (faceDataArray: FaceData[]) => void;
+    /**
+     * Passes the information about the detected feet. If this callback is set, it will get called every frame when a foot is detected.
+     * @param leftFootData Information about the left foot.
+     * @param rightFootData Information about the right foot.
+     */
+    onFeetTracked?: (leftFootData: FootData, rightFootData: FootData) => void;
+    /**
+     * Called when foot tracking is fully initialized.
+     * Be sure to check {@link DeepAR.isFootTrackingInitialized} before setting this callback.
+     * Because this callback is called only once. So if you set this callback after the foot tracking is initialized, it will not be called again.
+     */
+    onFootTrackingInitialized?: () => void;
+    /**
+     * Called when segmentation is fully initialized.
+     * Be sure to check {@link DeepAR.isSegmentationInitialized} before setting this callback.
+     * Because this callback is called only once. So if you set this callback after the segmentation is initialized, it will not be called again.
+     */
+    onSegmentationInitialized?: () => void;
+    /**
+     * Called when the animation player transitions to a new state.
+     * @param newState Name of the new state that is being transitioned to.
+     */
+    onAnimationTransitionedToState?: (newState: string) => void;
+}

package/js/types/faceData.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Information about the face being tracked. FaceData object is constructed and passed in the {@link DeepARCallbacks.onFaceTracked} callback.
+ */
+export interface FaceData {
+    /**
+     * True if the face is detected, false otherwise.
+     */
+    detected: boolean;
+    /**
+     * Array of 3 floats containing (x, y, z) position (translation) of the face in 3D space.
+     */
+    translation: number[];
+    /**
+     * Array of 3 floats containing (x, y, z) rotation of the face in 3D space.
+     */
+    rotation: number[];
+    /**
+     * Array of 16 floats containing 4x4 matrix representing translation and rotation of the face in 3D space.
+     */
+    poseMatrix: number[];
+    /**
+     * Array of 63*3 floats containing (x, y, z) positions of the 3D face landmarks. Read more <a href="https://help.deepar.ai/en/articles/4351347-deepar-reference-tracking-models">here</a>.
+     */
+    landmarks: number[];
+    /**
+     * Array of 63*2 floats containing (x, y) positions of the 2D face landmarks in screen space. Usually more precise than 3D points but no estimation for z translation. Read more here about feature points. Read more <a href="https://help.deepar.ai/en/articles/4351347-deepar-reference-tracking-models">here</a>.
+     */
+    landmarks2d: number[];
+    /**
+     * Array of 4 floats. Rectangle (x, y, width, height) containing the face in screen coordinates.
+     */
+    faceRect: number[];
+}

package/js/types/footData.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Information about the feet being tracked. FootData object is constructed and passed in the {@link DeepARCallbacks.onFeetTracked} callback.
+ */
+export interface FootData {
+    /**
+     * True if the foot is detected, false otherwise.
+     */
+    detected: boolean;
+}

package/js/types/footTrackingConfig.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Foot tracking initialization parameters.
+ */
+export interface DeepARFootTrackingConfig {
+    /**
+     * Path to the pose estimation wasm file, e.g. "/path/to/libPoseEstimation.wasm".
+     */
+    poseEstimationWasmPath?: string;
+    /**
+     * Path to the detector model, e.g. "/path/to/foot-detector-ios.bin".
+     */
+    detectorPath?: string;
+    /**
+     * Path to the tracker model, e.g. "/path/to/foot-tracker-ios.bin".
+     */
+    trackerPath?: string;
+    /**
+     * Path to the foot model object file, e.g. "/path/to/foot-model.obj".
+     */
+    objPath?: string;
+}

package/js/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './version';
+export * from './DeepAR';
+export * from './initParams';
+export * from './callbacks';
+export * from './faceData';
+export * from './footData';
+export * from './touchType';

package/js/types/initParams.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Parameters for the initialization of {@link DeepAR} object.
+ */
+export interface DeepARParams {
+    /**
+     * License key created on <a href="https://developer.deepar.ai/">DeepAR developer portal</a> for your web app.
+     */
+    licenseKey: string;
+    /**
+     * Canvas element where DeepAR will render the camera and effects/filters.
+     */
+    canvas: HTMLCanvasElement;
+    /**
+     *  The URL of a DeepAR effect file. This effect will be applied when DeepAR is initialized.
+     *  This parameter is optional. You can always later switch to a different effect with {@link DeepAR.switchEffect}.
+     */
+    effect?: string;
+    /**
+     * Path to the root directory of the DeepAR SDK. Most often this is used to provide the path to the root of the CDN that hosts the DeepAR SDK.
+     * For example "https://cdn.jsdelivr.net/npm/deepar@4.0.3/".<br>
+     *
+     * > ⚠️ <b>Be sure that the version of DeepAR js file and the root SDK path match!</b>
+     *
+     * This path will be used to locate and download all the additional needed files like ML models.
+     * DeepAR SDK can be hosted on any other server, but be sure not to change the directory and file structure of DeepAR SDK when hosing it.<br>
+     *
+     * To configure usage of non-default ML models, define them in the {@link additionalOptions}.
+     */
+    rootPath?: string;
+    /**
+     * TODO
+     */
+    additionalOptions?: {
+        /**
+         * By default, DeepAR preview will use the user facing camera. With these options you can disable the default camera usage or change the facing mode.
+         */
+        cameraConfig?: {
+            /**
+             * Can be "user" or "environment". User will be a front facing camera on mobile devices, while environment will be the back facing camera.
+             */
+            facingMode?: string;
+            /**
+             * If true, DeepAR will not use camera preview by default. You can use your own camera/video by calling {@link DeepAR.setVideoElement} or start the camera at any time by calling {@link DeepAR.startCamera}
+             */
+            disableDefaultCamera?: boolean;
+        };
+        /**
+         * Provide a hint or hints to DeepAR to optimize the SDK in some scenarios. <br><br>
+         * Available hints:
+         * <ul>
+         *     <li><b>face</b> - Will initialize face tracking as soon as possible. Without this hint face tracking is lazy loaded when some face tracking effect is loaded.</li>
+         *     <li><b>segmentation</b> - Will initialize segmentation as soon as possible. Without this hint segmentation is lazy loaded when some segmentation effect is loaded.</li>
+         *     <li><b>foot</b> - Will initialize foot tracking as soon as possible. Without this hint foot tracking is lazy loaded when some foot tracking effect is loaded.</li>
+         * </ul>
+         */
+        hint?: string | string[];
+        /**
+         * TODO
+         */
+        faceTrackingConfig?: {
+            /**
+             * TODO
+             */
+            modelPath: string;
+        };
+        /**
+         * Object containing configuration about the DeepAR segmentation which is used by background removal effects.
+         */
+        segmentationConfig?: {
+            /**
+             * Path to the segmentation model. Something like "path/to/segmentation-192x192.bin".
+             */
+            modelPath: string;
+        };
+        /**
+         * Object containing configuration for DeepAR foot tracking which is used for virtual shoe try on.
+         */
+        footTrackingConfig?: {
+            /**
+             * Path to the pose estimation wasm file, e.g. "/path/to/libPoseEstimation.wasm".
+             */
+            poseEstimationWasmPath?: string;
+            /**
+             * Path to the detector model, e.g. "/path/to/foot-detector-ios.bin".
+             */
+            detectorPath?: string;
+            /**
+             * Path to the tracker model, e.g. "/path/to/foot-tracker-ios.bin".
+             */
+            trackerPath?: string;
+            /**
+             * Path to the foot model object file, e.g. "/path/to/foot-model.obj".
+             */
+            objPath?: string;
+        };
+        /**
+         * Path to deepar.wasm file. Something like "path/to/deepar.wasm".
+         */
+        deeparWasmPath?: string;
+    };
+}

package/js/types/logType.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @internal
+ * Enum that defines possible types of logging messages.
+ */
+export declare enum LogType {
+    /**
+     * Information logging message.
+     */
+    INFO = 1,
+    /**
+     * Warning logging message.
+     */
+    WARNING = 2,
+    /**
+     * Error logging message.
+     */
+    ERROR = 3
+}

package/js/types/platformDetect.d.ts

@@ -0,0 +1,17 @@
+declare const gui: boolean;
+declare const terminal: boolean;
+declare const node: boolean;
+declare global {
+    interface Window {
+        MSStream: any;
+    }
+}
+declare const android: boolean;
+declare const chromeos: boolean;
+declare const tizen: boolean;
+declare const ios: boolean;
+declare const linuxBased: boolean;
+declare const windows: boolean;
+declare const macos: boolean;
+declare const linux: boolean;
+export { gui, terminal, node, android, chromeos, tizen, ios, linuxBased, windows, macos, linux, };

package/js/types/touchType.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Describes the touch/click type.
+ */
+export declare enum ARTouchType {
+    /**
+     * Touch started.
+     */
+    Start = 0,
+    /**
+     * Touch is pressed and is being moved.
+     */
+    Move = 1,
+    /**
+     * Touch ended.
+     */
+    End = 2
+}
+/**
+ * Information about the touch. Used by {@link DeepAR.touchOccurred}.
+ */
+export interface ARTouchInfo {
+    /**
+     * X coordinate.
+     */
+    x: number;
+    /**
+     * Y coordinate
+     */
+    y: number;
+    /**
+     * Touch type.
+     */
+    touchType: ARTouchType;
+}

package/js/types/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * DeepAR Web SDK version.
+ */
+declare const version = "5.0.0-alpha-1";
+export { version };

package/js/types/videoRecordingOptions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parameters that specify the format of recorded videos. Used by {@link DeepAR.startVideoRecording}.
+ */
+export interface VideoRecordingOptions {
+    /**
+     * A MIME type specyfing the format for the resulting video, such as `video/webm` or `video/mp4`.
+     * Corresponds to the MIME type used by <a href="https://developer.mozilla.org/en-US/docs/Web/API/Blob">Blob</a>
+     * objects and <a href="https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder">MediaRecorder</a>
+     * from the MediaStream Recording API.
+     *
+     * Note that `video/mp4` may not be supported in all browsers.
+     */
+    mimeType?: string;
+}

package/js/types/wrapper.d.ts

@@ -0,0 +1,10 @@
+export * from './version';
+export * from './DeepAR';
+export * from './initParams';
+export * from './callbacks';
+export * from './footTrackingConfig';
+export * from './faceData';
+export * from './footData';
+export * from './videoRecordingOptions';
+export * from './touchType';
+export * from './logType';

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "deepar",
-  "version": "4.1.0",
+  "version": "5.0.0-alpha-1",
   "description": "The official DeepAR Web SDK",
   "main": "js/deepar.esm.js",
-  "typings": "js/deepar.esm.d.ts",
+  "jsdelivr": "js/deepar.js",
+  "typings": "js/types/index.d.ts",
   "keywords": [
     "deepar",
     "web",
     "sdk",
     "ar",
-    "effects"
+    "effects",
+    "bacground removal",
+    "bacground replacement",
+    "background blur",
+    "shoe try-on",
+    "AR mini-games"
   ],
   "author": "deepar",
   "license": "SEE LICENSE IN LICENSE.txt"