@wix/editor-react-components 1.2153.0

package/dist/site/components/TransparentVideo/component.preview.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+import { TransparentVideoBuilderProps } from './TransparentVideo.types';
+import { ResolveManifestOverrides } from '../../../utils/ResolveManifestOverrides';
+export default function VideoUploadPreview(props: TransparentVideoBuilderProps): React.JSX.Element;
+export declare const resolveManifestOverrides: ResolveManifestOverrides;

package/dist/site/components/TransparentVideo/css.css

@@ -0,0 +1,112 @@
+.mainWrapper__gc4Bd {
+  overflow: hidden;
+  position: relative;
+}
+.mainWrapper__gc4Bd[data-show-canvas] .canvas__fJeLY {
+  opacity: 1;
+}
+.mainWrapper__gc4Bd:hover .audioToggle__k2EqB, .mainWrapper__gc4Bd:hover .playWrapper__yH3ix {
+  opacity: 1;
+}
+.mainWrapper__gc4Bd:hover .playWrapper__yH3ix svg {
+  transform: scale(1.05);
+}
+
+.videoWrapper__e-kgj {
+  visibility: hidden;
+  opacity: 0;
+  width: 0;
+  height: 0;
+}
+
+.canvas__fJeLY {
+  position: relative;
+  width: 100%;
+  height: 100%;
+  opacity: 0;
+  pointer-events: none;
+  object-fit: contain;
+  object-position: center center;
+}
+.canvas__fJeLY.hidden__L52Wy {
+  width: 0;
+  height: 0;
+}
+
+.poster__d1pI5 {
+  object-fit: contain;
+  width: 100%;
+  height: 100%;
+  position: relative;
+  background: transparent;
+}
+
+.playWrapper__yH3ix {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  opacity: 0;
+  transition: opacity 500ms ease;
+}
+.playWrapper__yH3ix.isShown__QBpcz, .playWrapper__yH3ix:hover {
+  opacity: 1;
+}
+.playWrapper__yH3ix svg {
+  transition: all 300ms ease;
+}
+
+.audioToggle__k2EqB {
+  opacity: 0;
+  transition: opacity 500ms ease;
+  position: absolute;
+  bottom: 0;
+  right: 0;
+}
+
+.filterEffectSvg__B9Lye {
+  height: 0;
+  width: 0;
+}
+.video-container__qOTQi {
+  width: 100%;
+  height: 100%;
+  display: block;
+  position: relative;
+  container-type: size;
+}
+
+.video-poster-img__bHEFW {
+  width: 100%;
+  height: 100%;
+  object-fit: var(--poster-fit, cover);
+  object-position: var(--poster-align, center);
+}
+
+.video__YuKrH {
+  height: 100%;
+  width: 100%;
+  top: 0;
+  left: 0;
+  position: absolute;
+  object-fit: var(--video-fit, cover);
+  opacity: 0;
+  --position-left: calc(50cqw - 1cqh * var(--focal-x, 50) * var(--aspect-ratio, 1));
+  --position-top: calc(50cqh - 1cqw * var(--focal-y, 50) / var(--aspect-ratio, 1));
+  object-position: var(--video-position, clamp(100%, var(--position-left), 0%) clamp(100%, var(--position-top), 0%));
+}
+.image__WopE9 {
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+.image__WopE9 img {
+  max-width: var(--wix-img-max-width, 100%);
+}
+.image__WopE9[data-animate-blur] img {
+  filter: blur(9px);
+  transition: filter 0.8s ease-in;
+}
+.image__WopE9[data-animate-blur] img[data-load-done] {
+  filter: none;
+}

package/dist/site/components/TransparentVideo/index.d.ts

@@ -0,0 +1,2 @@
+export * from './component';
+export { default, default as TransparentVideo } from './component';

package/dist/site/components/TransparentVideo/index.js

@@ -0,0 +1,6 @@
+'use client';
+
+import TransparentVideo from './component.js';
+
+export { TransparentVideo };
+export default TransparentVideo;

package/dist/site/components/TransparentVideo/kampos/transparent-video.d.ts

@@ -0,0 +1,29 @@
+export default function transparentVideo(): {
+    vertex: {
+        uniform: {
+            u_texOffset: string;
+        };
+        main: string;
+    };
+    fragment: {
+        uniform: {
+            u_tvEnabled: string;
+        };
+        main: string;
+    };
+    disabled: boolean;
+    varying: {
+        v_texAlphaCoord: string;
+    };
+    uniforms: {
+        name: string;
+        type: string;
+        data: number[];
+    }[];
+    attributes: {
+        name: string;
+        data: Float32Array;
+        size: number;
+        type: string;
+    }[];
+};

package/dist/site/components/TransparentVideo/kampos/transparentVideoUtils.d.ts

@@ -0,0 +1,29 @@
+import { Kampos } from 'kampos';
+import type * as React from 'react';
+type FilterEffect = {
+    brightness?: number;
+    contrast?: number;
+    duotoneDark?: string;
+    duotoneLight?: string;
+    hue?: number;
+    saturation?: number;
+};
+declare function tvControllerFactory({ filterEffect, playerRef, videoRef, canvasRef, contextRef, kampos, setCanPlayTV, }: {
+    filterEffect: FilterEffect | undefined;
+    playerRef: React.RefObject<HTMLDivElement>;
+    videoRef: React.RefObject<HTMLVideoElement>;
+    canvasRef: React.RefObject<HTMLCanvasElement>;
+    contextRef: React.RefObject<unknown>;
+    kampos: React.MutableRefObject<any>;
+    setCanPlayTV: React.Dispatch<React.SetStateAction<boolean>>;
+}): {
+    initKampos(): void;
+    playKampos(): void;
+    stopKampos(): void;
+    killKampos(): void;
+    removePoster(): void;
+    showPoster(): void;
+    onViewEnter(): void;
+    onViewLeave(): void;
+};
+export { Kampos, tvControllerFactory };

package/dist/site/components/TransparentVideo/manifest.d.ts

@@ -0,0 +1,5 @@
+import { EditorReactComponent } from '@wix/component-protocol/schema';
+declare const manifest: EditorReactComponent & {
+    id: string;
+};
+export default manifest;

package/dist/site/components/TransparentVideo/manifest.js

@@ -0,0 +1,204 @@
+import { D as DATA, b as DISPLAY_GROUPS, a as ACTIONS, I as INTERACTIONS, A as Archetype, L as LAYOUT } from "../chunks/chunk-JPMZBG44.js";
+import { V as VideoCategoryTypes } from "../chunks/types.impl.js";
+import { a as VideoEndType, V as VideoStartType } from "../chunks/TransparentVideo.types.js";
+const manifest = {
+  id: "a5d9e3b7-1f62-4c8a-b0d4-9e3f7a2c6b11",
+  type: "wixEditorElements.TransparentVideo",
+  description: "Allows users to display transparent videos",
+  installation: {
+    initialSize: {
+      width: {
+        sizingType: LAYOUT.SIZING_TYPE.pixels,
+        pixels: 400
+      },
+      height: {
+        sizingType: LAYOUT.SIZING_TYPE.pixels,
+        pixels: 225
+      },
+      preserveAspectRatio: true
+    }
+  },
+  editorElement: {
+    selector: ".wixui-transparent-video",
+    displayName: "Transparent Video",
+    archetype: Archetype.Video,
+    interactions: {
+      triggers: [
+        INTERACTIONS.TRIGGER_TYPE.viewEnter,
+        INTERACTIONS.TRIGGER_TYPE.viewProgress,
+        INTERACTIONS.TRIGGER_TYPE.pointerMove
+      ],
+      effectGroups: [INTERACTIONS.EFFECT_GROUP.UNKNOWN_EFFECT_GROUP]
+    },
+    customActions: {
+      coverImage: {
+        displayName: "Change Cover",
+        execution: {
+          actionType: ACTIONS.ACTION_TYPE.panel,
+          panel: {
+            panelType: ACTIONS.PANEL_TYPE.panelId,
+            panelId: "a7f3b8c2-4e5d-4f8a-8b1c-2d3e4f5a6b7c"
+          }
+        }
+      },
+      vectorArtColors: {
+        displayName: "Recolor Video",
+        execution: {
+          actionType: ACTIONS.ACTION_TYPE.panel,
+          panel: {
+            panelType: ACTIONS.PANEL_TYPE.panelId,
+            panelId: "a9b7d3e1-2f6c-4a88-97de-5c1f2b8a4d90"
+          }
+        }
+      }
+    },
+    displayGroups: {
+      behavior: {
+        displayName: "Behavior",
+        groupType: DISPLAY_GROUPS.GROUP_TYPE.data,
+        data: {
+          items: ["videoStartType", "videoEndType"]
+        }
+      }
+    },
+    data: {
+      filterEffectRecolorVideo: {
+        displayName: "Filter Effect Recolor",
+        dataType: DATA.DATA_TYPE.booleanValue,
+        defaultValue: false
+      },
+      effectType: {
+        displayName: "Filter Effect Type",
+        dataType: DATA.DATA_TYPE.text,
+        defaultValue: null
+      },
+      duotoneDark: {
+        displayName: "Filter Effect Duotone Dark",
+        dataType: DATA.DATA_TYPE.text,
+        defaultValue: null
+      },
+      duotoneLight: {
+        displayName: "Filter Effect Duotone Light",
+        dataType: DATA.DATA_TYPE.text,
+        defaultValue: null
+      },
+      brightness: {
+        displayName: "Filter Effect Brightness",
+        dataType: DATA.DATA_TYPE.number,
+        defaultValue: null
+      },
+      contrast: {
+        displayName: "Filter Effect Contrast",
+        dataType: DATA.DATA_TYPE.number,
+        defaultValue: null
+      },
+      isCustom: {
+        displayName: "Filter Effect Is Custom",
+        dataType: DATA.DATA_TYPE.booleanValue,
+        defaultValue: false
+      },
+      hue: {
+        displayName: "Filter Effect Hue",
+        dataType: DATA.DATA_TYPE.number,
+        defaultValue: null
+      },
+      saturation: {
+        displayName: "Filter Effect Saturation",
+        dataType: DATA.DATA_TYPE.number,
+        defaultValue: null
+      },
+      video: {
+        dataType: DATA.DATA_TYPE.video,
+        [DATA.DATA_TYPE.video]: {
+          category: VideoCategoryTypes.VIDEO_TRANSPARENT
+        },
+        disableDeletion: true
+      },
+      mute: {
+        displayName: "Mute on play",
+        dataType: DATA.DATA_TYPE.booleanValue,
+        defaultValue: true
+      },
+      playbackRate: {
+        displayName: "Playback speed",
+        dataType: DATA.DATA_TYPE.number,
+        defaultValue: 1
+      },
+      videoStartType: {
+        displayName: "How does it start to play?",
+        dataType: DATA.DATA_TYPE.textEnum,
+        defaultValue: VideoStartType.auto,
+        [DATA.DATA_TYPE.textEnum]: {
+          options: [
+            { value: VideoStartType.auto, displayName: "Automatically" },
+            { value: VideoStartType.click, displayName: "On click" },
+            { value: VideoStartType.hover, displayName: "On hover" }
+          ]
+        }
+      },
+      videoEndType: {
+        displayName: "How does it end?",
+        dataType: DATA.DATA_TYPE.textEnum,
+        defaultValue: VideoEndType.loop,
+        [DATA.DATA_TYPE.textEnum]: {
+          options: [
+            { value: VideoEndType.loop, displayName: "Loops" },
+            {
+              value: VideoEndType.replayOnClick,
+              displayName: "Replays on click"
+            },
+            { value: VideoEndType.stop, displayName: "Stop" }
+          ]
+        }
+      },
+      a11y: {
+        dataType: DATA.DATA_TYPE.a11y,
+        [DATA.DATA_TYPE.a11y]: {
+          attributes: [
+            DATA.A11Y_ATTRIBUTES.role,
+            DATA.A11Y_ATTRIBUTES.tabIndex,
+            DATA.A11Y_ATTRIBUTES.ariaLabel,
+            DATA.A11Y_ATTRIBUTES.ariaLive,
+            DATA.A11Y_ATTRIBUTES.ariaRoledescription,
+            DATA.A11Y_ATTRIBUTES.ariaLevel,
+            DATA.A11Y_ATTRIBUTES.ariaHidden,
+            DATA.A11Y_ATTRIBUTES.ariaAtomic,
+            DATA.A11Y_ATTRIBUTES.ariaCurrent,
+            DATA.A11Y_ATTRIBUTES.ariaRelevant
+          ]
+        }
+      }
+    },
+    displayFilters: {
+      data: {
+        hide: [
+          "playbackRate",
+          "filterEffectRecolorVideo",
+          "effectType",
+          "duotoneDark",
+          "duotoneLight",
+          "brightness",
+          "contrast",
+          "isCustom",
+          "hue",
+          "saturation"
+        ]
+      }
+    },
+    helpArticle: {
+      kbId: "39a8c672-5bf5-4a39-bfd8-755db3f8f22c"
+    }
+  },
+  resources: {
+    client: {
+      componentUrl: "./site/components/TransparentVideo/component.tsx",
+      moduleSpecifier: "@wix/editor-react-components/TransparentVideo"
+    },
+    editor: {
+      componentUrl: "./site/components/TransparentVideo/component.preview.tsx"
+    }
+  }
+};
+export {
+  manifest as default
+};

package/dist/site/components/TransparentVideo/panels/PanelViewCustom.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { TransparentVideoFilterEffect } from '../TransparentVideo.types';
+import { Translations } from './translation';
+interface PanelViewCustomProps {
+    onBackClick: () => void;
+    onCustomFieldChange: (updatedData: TransparentVideoFilterEffect) => void;
+    customFilterEffectData: TransparentVideoFilterEffect;
+    onCustomPresetSelected: (p: TransparentVideoFilterEffect) => void;
+    translations: Translations;
+}
+export declare const PanelViewCustom: React.MemoExoticComponent<(props: PanelViewCustomProps) => React.JSX.Element>;
+export {};

package/dist/site/components/TransparentVideo/panels/PanelViewPresets.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { FilterEffectType, TransparentVideoFilterEffect } from '../TransparentVideo.types';
+import { Translations } from './translation';
+interface PanelViewPresetsProps {
+    selectedFilterType?: FilterEffectType;
+    filterEffectRecolorVideo: boolean;
+    onNoneClick: () => void;
+    onCustomSelect: () => void;
+    onEditCustomClick: () => void;
+    onPresetClick: (preset: TransparentVideoFilterEffect) => void;
+    posterUrl: string;
+    containerId: string;
+    customFilterEffectData: TransparentVideoFilterEffect | null;
+    translations: Translations;
+}
+export declare const PanelViewPresets: React.MemoExoticComponent<(props: PanelViewPresetsProps) => React.JSX.Element>;
+export {};

package/dist/site/components/TransparentVideo/panels/RangeInput.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+interface RangeInputProps {
+    label: string;
+    max: number;
+    min: number;
+    step: number;
+    value: number;
+    onChange: (value: number) => void;
+    suffix?: string;
+    displayMarks?: boolean;
+}
+export declare const RangeInput: React.MemoExoticComponent<(props: RangeInputProps) => React.JSX.Element>;
+export {};

package/dist/site/components/TransparentVideo/panels/bi/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const reportRecolorChange: (oldVal?: string, newVal?: string) => void;
+export declare const reportCoverChange: (oldVal: string, newVal: string) => void;

package/dist/site/components/TransparentVideo/panels/extension.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    type: string;
+};
+export default _default;

package/dist/site/components/TransparentVideo/panels/panel.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const _default: () => React.JSX.Element | null;
+export default _default;

package/dist/site/components/TransparentVideo/panels/presets.d.ts

@@ -0,0 +1,3 @@
+import { TransparentVideoFilterEffect } from '../TransparentVideo.types';
+export declare const customFilterDefaultValues: TransparentVideoFilterEffect;
+export declare const presets: Array<TransparentVideoFilterEffect>;

package/dist/site/components/TransparentVideo/panels/translation.d.ts

@@ -0,0 +1,22 @@
+export declare const TranslationKeys: {
+    readonly tvDuotone: "transparentVideo.recolorVideoPanel.coloringStyle.duotone.option";
+    readonly tvMonotoneDark: "transparentVideo.recolorVideoPanel.coloringStyle.darkWash.option";
+    readonly tvMonotoneLight: "transparentVideo.recolorVideoPanel.coloringStyle.lightWash.option";
+    readonly grayscale: "transparentVideo.recolorVideoPanel.coloringStyle.grayscale.option";
+    readonly tvHue: "transparentVideo.recolorVideoPanel.coloringStyle.hue.option";
+    readonly custom: "transparentVideo.recolorVideoPanel.coloringStyle.custom.option";
+    readonly customize: "transparentVideo.recolorVideoPanel.coloringStyle.customize.option";
+    readonly none: "transparentVideo.recolorVideoPanel.coloringStyle.none.option";
+    readonly chooseDarks: "transparentVideo.recolorVideoPanel.chooseDarks.label";
+    readonly chooseLights: "transparentVideo.recolorVideoPanel.chooseLights.label";
+    readonly chooseAColor: "transparentVideo.recolorVideoPanel.chooseAColor.label";
+    readonly back: "transparentVideo.recolorVideoPanel.back.button";
+    readonly resetToOriginalColors: "transparentVideo.recolorVideoPanel.resetToOriginalColors.button";
+    readonly coloringStyle: "transparentVideo.recolorVideoPanel.coloringStyle.label";
+    readonly brightness: "transparentVideo.recolorVideoPanel.brightness.label";
+    readonly contrast: "transparentVideo.recolorVideoPanel.contrast.label";
+    readonly hueValue: "transparentVideo.recolorVideoPanel.hueValue.label";
+    readonly saturation: "transparentVideo.recolorVideoPanel.saturation.label";
+};
+export type Translations = Record<keyof typeof TranslationKeys, string>;
+export declare const DefaultTranslations: Translations;

package/dist/site/components/TransparentVideo/svgFilters/svgFilters.d.ts

@@ -0,0 +1,8 @@
+import { FilterOverridesOrEmpty, SvgShadow } from './typing';
+declare function getFilter(id: string, name: string, overrides: FilterOverridesOrEmpty, attrs: any): string;
+declare function getShadow(id: string, shadow: SvgShadow): string;
+declare function getProperties(name: string, overrides: FilterOverridesOrEmpty): {
+    [x: string]: string | number | SvgShadow | import('./typing').DuotoneValue | import('./typing').OffsetValue | import('./typing').LumaValue | null | undefined;
+}[];
+declare function isFilterExists(effectName: string): boolean;
+export { getFilter, getShadow, getProperties, isFilterExists };

package/dist/site/components/TransparentVideo/svgFilters/svgFiltersParts.d.ts

@@ -0,0 +1,16 @@
+import { RGB } from './typing';
+declare function getSepia(amount: number): string;
+declare function getContrast(amount: number): string;
+declare function getBrightness(amount: number): string;
+declare function getTint(color: RGB): string;
+declare function getLumaMatrix(whiteParams: RGB, blackParams: RGB): string;
+declare function getColor(color: RGB, opacity?: number): string;
+declare function getDoutone(light: RGB, dark: RGB): string;
+declare function getAlpha(amount: number): string;
+declare function hexToRgb(hex: string): RGB;
+declare function hex2RgbNorm(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+};
+export { getDoutone, hexToRgb, hex2RgbNorm, getColor, getContrast, getSepia, getBrightness, getTint, getAlpha, getLumaMatrix, };

package/dist/site/components/TransparentVideo/svgFilters/svgFiltersTemplates.d.ts

@@ -0,0 +1,6 @@
+import { FilterDefinition, DuotoneValue, FilterOverridesOrEmpty } from './typing';
+declare function interpolate(id: string, filterDefinition: Array<FilterDefinition>, overrides: FilterOverridesOrEmpty, attrs?: any): string;
+declare function getProperties(filterDefinition: Array<FilterDefinition>, overrides: FilterOverridesOrEmpty): {
+    [x: string]: string | number | import('./typing').SvgShadow | DuotoneValue | import('./typing').OffsetValue | import('./typing').LumaValue | null | undefined;
+}[];
+export { interpolate, getProperties };

package/dist/site/components/TransparentVideo/svgFilters/svgPresets.d.ts

@@ -0,0 +1,6 @@
+import { FilterDefinition } from './typing';
+type FilterPresets = {
+    [key: string]: Array<FilterDefinition>;
+};
+export declare const filterPresets: FilterPresets;
+export {};

package/dist/site/components/TransparentVideo/svgFilters/typing.d.ts

@@ -0,0 +1,67 @@
+export type SvgShadow = {
+    x?: number;
+    y?: number;
+    blurRadius?: number;
+    color: string;
+    opacity?: number;
+    mergeGraphic?: boolean;
+    dark?: string;
+    light?: string;
+};
+export type DuotoneValue = {
+    dark: string;
+    light: string;
+};
+export type OffsetValue = {
+    x: number;
+    y: number;
+};
+export type LumaValue = {
+    dark: RGB;
+    light: RGB;
+};
+type FilterDefinitionBase = {
+    inAttr?: string;
+    in2Attr?: string;
+    result?: string;
+};
+export type FilterDefinitionSvgShadow = FilterDefinitionBase & {
+    key: 'shadow' | 'duotone' | 'color' | 'offset';
+    value: SvgShadow;
+};
+export type FilterDefinitionNumber = FilterDefinitionBase & {
+    key: 'blur' | 'saturation' | 'contrast' | 'brightness' | 'sepia' | 'hue' | 'alpha';
+    value: number;
+};
+export type FilterDefinitionString = FilterDefinitionBase & {
+    key: 'color' | 'tint' | 'blend' | 'composite';
+    value: string;
+};
+export type FilterDefinitionIdentity = FilterDefinitionBase & {
+    key: 'identity';
+    value?: null;
+};
+export type FilterDefinitionLuma = FilterDefinitionBase & {
+    key: 'luma';
+    value: LumaValue;
+};
+export type FilterDefinitionDuotone = FilterDefinitionBase & {
+    key: 'duotone';
+    value: DuotoneValue;
+};
+export type FilterDefinitionOffset = FilterDefinitionBase & {
+    key: 'offset';
+    value: OffsetValue;
+};
+export type FilterDefinition = FilterDefinitionNumber | FilterDefinitionSvgShadow | FilterDefinitionDuotone | FilterDefinitionIdentity | FilterDefinitionLuma | FilterDefinitionOffset | FilterDefinitionString;
+export type FilterOverrides = Record<FilterDefinition['key'], FilterDefinition['value']> & {
+    duotoneLight?: string;
+    duotoneDark?: string;
+};
+export type FilterOverridesOrEmpty = FilterOverrides | {};
+export type RGB = {
+    r: number;
+    g: number;
+    b: number;
+};
+export {};

package/dist/site/components/TransparentVideo/transparentVideoPoster.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export interface TransparentVideoPosterProps {
+    posterFilterId: string;
+    posterUrl: string;
+    containerId: string;
+    ariaLabel?: string;
+    filterEffectSvgString?: string;
+}
+export declare const TransparentVideoPoster: React.MemoExoticComponent<(props: TransparentVideoPosterProps) => React.JSX.Element>;

package/dist/site/components/TransparentVideo/useTransparentVideo.d.ts

@@ -0,0 +1,25 @@
+import { MouseEvent } from 'react';
+import { TransparentVideoProps, VideoEndType } from './TransparentVideo.types';
+export declare function useTransparentVideo(props: TransparentVideoProps): {
+    a11y: Pick<typeof import('@wix/ambassador-devcenter-v1-component-type-data/types').A11yAttributes, "ariaLabel"> | undefined;
+    className: string | undefined;
+    canvasRef: import('react').RefObject<HTMLCanvasElement>;
+    isMuted: boolean;
+    isPlaying: boolean;
+    id: string;
+    shouldMuteVideo: boolean;
+    onAudioToggleClickHandler: (event: MouseEvent<HTMLDivElement>) => void;
+    onClickHandler: () => void;
+    onMouseEnterHandler: () => void;
+    onMouseOutHandler: () => void;
+    shouldAutoplay: boolean;
+    playbackRate: number;
+    playerRef: import('react').RefObject<HTMLDivElement>;
+    shouldDisplayPoster: boolean;
+    video: import('@wix/video').VideoMedia | undefined;
+    videoEndType: VideoEndType;
+    videoRef: import('react').RefObject<HTMLVideoElement>;
+    posterFilterId: string;
+    shouldDisplayAudioToggle: boolean;
+    shouldDisplayPlayButton: boolean;
+};

package/dist/site/components/TransparentVideo/utils.d.ts

@@ -0,0 +1,8 @@
+import { TransparentVideoBuilderProps, TransparentVideoFilterEffect } from './TransparentVideo.types';
+export declare const getFilterEffectString: (id: string, filterEffect?: TransparentVideoFilterEffect) => string;
+export declare const formatPosterUrl: (uri: string, width?: number, height?: number) => string | undefined;
+export declare const SVG_FILTER_ID_PREFIX = "svg_filter_";
+export declare const replaceCompIdPlaceholder: (str: string, compId: string) => string;
+export declare const getActiveFilterEffect: (props: Partial<TransparentVideoBuilderProps>) => TransparentVideoFilterEffect | undefined;
+export declare const getFilterEffectData: (props: Partial<TransparentVideoBuilderProps>) => TransparentVideoFilterEffect;
+export declare const closeSelfClosingSvgTags: (svg: string) => string;

package/dist/site/components/VideoUpload/VideoUpload.semanticClassNames.d.ts

@@ -0,0 +1,5 @@
+declare const semanticClassNames: {
+    readonly root: "video-upload";
+    readonly title: "video-upload__title";
+};
+export default semanticClassNames;