@webitel/ui-sdk 25.12.31 → 25.12.33

package/src/components/wt-vidstack-player/wt-vidstack-player.vue

@@ -1,11 +1,12 @@
 <template>
   <div
     class="wt-vidstack-player"
-    :class="{[`wt-vidstack-player--${size}`]: props.resizable}"
+    :class="{[`wt-vidstack-player--${size}`]: props.resizable,
+      'wt-vidstack-player--static': props.staticPosition}"
   >
     <media-player
       ref="player"
-      :src="playerSrc"
+      :src="normalizedSrc"
       :autoplay="props.autoplay"
       :muted="props.muted"
       class="wt-vidstack-player__player"
@@ -20,6 +21,7 @@
 
       <video-layout
         v-if="props.resizable"
+        :hide-display-panel="props.hideDisplayPanel"
         :closable="props.closable"
         :autoplay="props.autoplay"
         :title="props.title"
@@ -50,7 +52,7 @@ import {ComponentSize} from '../../enums';
 import {VideoLayout} from "./components";
 
 interface Props {
-  src: string | { src: string; type?: string };
+  src?: string | { src: string; type?: string };
   mime?: string;
   autoplay?: boolean;
   muted?: boolean;
@@ -58,7 +60,10 @@ interface Props {
   username?: string;
   closable?: boolean;
   resizable?: boolean;
+  staticPosition?: boolean;
   stream?: MediaStream
+  componentSize?: keyof typeof ComponentSize
+  hideDisplayPanel?: boolean
 }
 
 const props = withDefaults(defineProps<Props>(), {
@@ -68,6 +73,7 @@ const props = withDefaults(defineProps<Props>(), {
   title: '',
   username: '',
   closable: false,
+  staticPosition: false,
   resizable: true,
 });
 
@@ -76,7 +82,7 @@ const emit = defineEmits<{
 }>()
 
 const player = useTemplateRef<MediaPlayerElement>('player');
-const size = ref(ComponentSize.SM);
+const size = ref(props.componentSize || ComponentSize.SM);
 
 const changeSize = (value) => {
   size.value = value;
@@ -90,58 +96,39 @@ provide('size', {size, changeSize});
 
 const normalizedType = computed(() => { // https://vidstack.io/docs/wc/player/core-concepts/loading/?styling=css#source-types
   if (props.mime) return props.mime;
-
-
-  if (props.src.includes('media')) return 'audio/mp3';
-  if (props.src.includes('mp3')) return 'audio/mp3';
-  if (props.src.includes('ogg') || props.src.includes('oga')) return 'audio/ogg';
+  
+  if (typeof props.src === 'string') {
+    if (props.src.includes('media')) return 'audio/mp3';
+    if (props.src.includes('mp3')) return 'audio/mp3';
+    if (props.src.includes('ogg') || props.src.includes('oga')) return 'audio/ogg';
+  }
 
   return 'video/mp4';
 });
 
-const playerSrc = computed(() => {
+const normalizedSrc = computed(() => {
+  if (props.stream) {
+    return {src: props.stream, type: 'video/object'};
+  }
+
   if (typeof props.src === 'string') {
-    return {src: props.src, type: normalizedType.value};
+    return { src: props.src, type: normalizedType.value };
   }
+
   return {
     src: props.src?.src || '',
     type: props.src?.type || normalizedType.value
   };
 });
 
-/** @author @Oleksandr Palonnyi
- * Binds the incoming MediaStream to the Vidstack player after mount.
- * A brief delay ensures the internal <video> element is ready before playback starts.
- */
-onMounted(() => {
-  if (player.value && props.stream) {
-    const videoEl = player.value.querySelector('video')
-
-    videoEl.addEventListener("loadedmetadata", async () => {
-      await videoEl.play().catch((err) => console.error('play error:', err))
-    })
-
-    if (videoEl.srcObject !== props.stream) {
-      setTimeout(() => {
-        videoEl.srcObject = props.stream ?? null
-      }, 200)
-    }
-  }
-})
-
-onBeforeUnmount(() => {
-  const videoEl = player.value.querySelector('video')
-  if (videoEl && videoEl.srcObject) {
-    videoEl.srcObject.getTracks().forEach(t => t.stop())
-    videoEl.srcObject = null
-  }
-})
 </script>
 
 <style scoped lang="scss">
 @use '../wt-popup/mixins.scss' as *;
 
 .wt-vidstack-player {
+  width: 100%;
+  height: 100%;
   transition: var(--transition);
 
   &__player {
@@ -169,17 +156,25 @@ onBeforeUnmount(() => {
   }
 
   &--md {
-    @include popup-wrapper;
+    &--md:not(.wt-vidstack-player--static) {
+      @include popup-wrapper;
+
+      .wt-vidstack-player__player {
+        @include popup-container;
+      }
+    }
+
     /** @author liza-pohranichna
     * need to use wt-popup styles for md size https://webitel.atlassian.net/browse/WTEL-7723 */
 
     .wt-vidstack-player__player {
-      @include popup-container;
       position: relative;
+      display: block;
       max-width: var(--p-player-wrapper-md-width);
       padding: 0;
       border-radius: var(--p-player-wrapper-md-border-radius);
       overflow: hidden;
+      box-shadow: var(--elevation-10);
     }
   }
 
@@ -196,6 +191,22 @@ onBeforeUnmount(() => {
       }
     }
   }
+
+  &--static {
+    position: relative;
+    right: unset;
+    bottom: unset;
+
+    .wt-vidstack-player__provider {
+      padding: 0;
+    }
+
+    .wt-vidstack-player__player {
+      margin: 0;
+      width: 100%;
+      height: 100%;
+    }
+  }
 }
 </style>
 

package/src/modules/CallSession/index.ts

@@ -1,4 +1,3 @@
-import ScreenSharing from './modules/ScreenSharing/screen-sharing.vue';
-import VideoCall from './modules/VideoCall/video-call.vue';
-
-export { ScreenSharing, VideoCall };
+export { default as ScreenSharing } from './modules/ScreenSharing/screen-sharing.vue';
+export { VideoCallAction } from './modules/VideoCall/enums/VideoCallAction.enum';
+export { default as VideoCall } from './modules/VideoCall/video-call.vue';

package/src/modules/CallSession/modules/ScreenSharing/screen-sharing.vue

@@ -35,7 +35,7 @@
 import {WtVidstackPlayer} from '@webitel/ui-sdk/components';
 import {defineEmits, useAttrs} from 'vue';
 
-import {RecordingIndicator,ScreenSharingControlsPanel} from "../../../../components/wt-vidstack-player/components";
+import {RecordingIndicator, ScreenSharingControlsPanel} from "../../../../components/wt-vidstack-player/components";
 import {ScreenSharingSession, ScreenshotStatus} from '../../types';
 
 interface Props {

package/src/modules/CallSession/modules/VideoCall/enums/VideoCallAction.enum.ts

@@ -0,0 +1,11 @@
+export const VideoCallAction = {
+  Screenshot: 'screenshot',
+  Recordings: 'recordings',
+  Mic: 'mic',
+  Video: 'video',
+  Settings: 'settings',
+  Chat: 'chat',
+  Hangup: 'hangup',
+} as const;
+
+export type VideoCallAction = (typeof VideoCallAction)[keyof typeof VideoCallAction];

package/src/modules/CallSession/modules/VideoCall/video-call.vue

@@ -1,6 +1,7 @@
 <template>
   <wt-vidstack-player
     :stream="mainStream"
+    :static-position="props.position === 'static'"
     class="video-call"
     autoplay
     muted
@@ -10,15 +11,36 @@
         :class="`video-call-content--${size}`"
         class="video-call-content"
       >
-        <wt-vidstack-player
-          :stream="props.receiver"
-          :resizable="false"
-          :class="`video-call-receiver--${size}`"
-          static
-          autoplay
-          muted
-          class="receiver"
-        />
+        <template v-if="!props['receiver:stream'] && !props['sender:video:enabled']">
+          <div
+            :class="`video-call-sender--${size}`"
+            class="video-call-sender video-call-sender--muted"
+          >
+            <wt-icon :size="receiverVideoMutedIconSizes[size]" icon="video-cam-off--filled" />
+          </div>
+        </template>
+
+        <template v-if="!props['receiver:stream'] && !props['receiver:video:enabled']">
+          <div
+            :class="`video-call-receiver--${size}`"
+            class="video-call-receiver video-call-receiver--muted"
+          >
+            <wt-icon :size="receiverVideoMutedIconSizes[size]" icon="video-cam-off--filled" />
+          </div>
+        </template>
+
+        <template v-else-if="props['receiver:stream']">
+          <wt-vidstack-player
+            :stream="props['receiver:stream']"
+            :resizable="false"
+            :class="`video-call-receiver--${size}`"
+            hide-display-panel
+            static-position
+            autoplay
+            muted
+            class="video-call-receiver"
+          />
+        </template>
 
         <div
           :class="`video-call__indicator--${size}`"
@@ -34,19 +56,21 @@
 
     <template #controls-panel>
       <video-call-controls-panel
+        :mic:enabled="props['sender:mic:enabled']"
+        :mic:accessed="props['sender:mic:accessed']"
+        :video:enabled="props['sender:video:enabled']"
+        :video:accessed="props['sender:video:accessed']"
+        :screenshot:status="props['screenshot:status']"
+        :screenshot:loading="props['screenshot:loading']"
         :recordings="props.recordings"
-        :is-mic-muted="props.isMicMuted"
-        :is-video-muted="props.isVideoMuted"
-        :is-call-started="props.isCallStarted"
-        :screenshot-status="props.screenshotStatus"
-        :screenshot-is-loading="props.screenshotIsLoading"
-        :screenshot-callback="props.screenshotCallback"
-        :recordings-callback="props.recordingsCallback"
-        :mic-callback="props.micCallback"
-        :video-callback="props.videoCallback"
-        :settings-callback="props.settingsCallback"
-        :chat-callback="props.chatCallback"
-        :call-state-callback="props.callStateCallback"
+        :actions="props.actions"
+        @[VideoCallAction.Screenshot]="([payload, options] = []) => emit(`action:${VideoCallAction.Screenshot}`, payload, options)"
+        @[VideoCallAction.Recordings]="([payload, options] = []) => emit(`action:${VideoCallAction.Recordings}`, payload, options)"
+        @[VideoCallAction.Mic]="([payload, options] = []) => emit(`action:${VideoCallAction.Mic}`, payload, options)"
+        @[VideoCallAction.Video]="([payload, options] = []) => emit(`action:${VideoCallAction.Video}`, payload, options)"
+        @[VideoCallAction.Settings]="([payload, options] = []) => emit(`action:${VideoCallAction.Settings}`, payload, options)"
+        @[VideoCallAction.Chat]="([payload, options] = []) => emit(`action:${VideoCallAction.Chat}`, payload, options)"
+        @[VideoCallAction.Hangup]="([payload, options] = []) => emit(`action:${VideoCallAction.Hangup}`, payload, options)"
       />
     </template>
   </wt-vidstack-player>
@@ -54,33 +78,61 @@
 
 <script setup lang="ts">
 import {WtVidstackPlayer} from '@webitel/ui-sdk/components';
-import {computed} from 'vue';
+import {computed } from 'vue';
 
+import {WtIcon} from "../../../../components";
 import {RecordingIndicator, VideoCallControlsPanel} from "../../../../components/wt-vidstack-player/components";
+import {ComponentSize} from "../../../../enums";
+import { ResultCallbacks } from '../../../../types';
 import {ScreenshotStatus} from '../../types';
+import { VideoCallAction } from './enums/VideoCallAction.enum';
 
-interface Props {
-  sender: MediaStream
-  receiver: MediaStream
-  isMicMuted: boolean
-  isVideoMuted: boolean
-  isCallStarted: boolean
-  recordings: boolean
-  screenshotStatus: ScreenshotStatus | null
-  screenshotIsLoading: boolean
-
-  screenshotCallback?: () => void
-  recordingsCallback?: () => void
-  micCallback?: () => void
-  videoCallback?: () => void
-  settingsCallback?: () => void
-  chatCallback?: () => void
-  callStateCallback?: () => void
-}
+const props = defineProps<{
+  'sender:stream'?: MediaStream | null;
+  
+  'sender:mic:enabled'?: boolean;
+  'sender:mic:accessed'?: boolean;
+  
+  'sender:video:enabled'?: boolean;
+  'sender:video:accessed'?: boolean;
+  
+  'receiver:stream'?: MediaStream | null;
+  'receiver:mic:enabled'?: boolean;
+  'receiver:video:enabled'?: boolean;
+  
+  'screenshot:status'?: ScreenshotStatus | null;
+  'screenshot:loading'?: boolean;
+  
+  recordings?: boolean;
+
+  position?: 'static' | 'left' | 'right';
+
+  actions: VideoCallAction[];
+}>();
+
+const emit = defineEmits<{
+  (e: `action:${typeof VideoCallAction.Screenshot}`, payload?: unknown, options?: ResultCallbacks): void;
+  (e: `action:${typeof VideoCallAction.Recordings}`, payload?: unknown, options?: ResultCallbacks): void;
+  (e: `action:${typeof VideoCallAction.Mic}`, payload?: unknown, options?: ResultCallbacks): void;
+  (e: `action:${typeof VideoCallAction.Video}`, payload?: unknown, options?: ResultCallbacks): void;
+  (e: `action:${typeof VideoCallAction.Settings}`, payload?: unknown, options?: ResultCallbacks): void;
+  (e: `action:${typeof VideoCallAction.Chat}`, payload?: unknown, options?: ResultCallbacks): void;
+  (e: `action:${typeof VideoCallAction.Hangup}`, payload?: unknown, options?: ResultCallbacks): void;
+}>()
+
+
+const mainStream = computed(() => {
+  if (!props['sender:video:enabled']) return null;
 
-const props = defineProps<Props>();
+  return props['receiver:stream'] || props['sender:stream'];
+})
+
+const receiverVideoMutedIconSizes = {
+  [ComponentSize.SM]: ComponentSize.MD,
+  [ComponentSize.SM]: ComponentSize.LG,
+  [ComponentSize.SM]: ComponentSize.XXL,
+}
 
-const mainStream = computed(() => props.receiver || props.sender)
 </script>
 
 <style lang="scss" scoped>
@@ -101,13 +153,42 @@ const mainStream = computed(() => props.receiver || props.sender)
     }
   }
 
+  &-sender {
+    background: var(--p-player-wrapper-background);
+    position: absolute;
+    left: 0;
+    top: 0;
+    width: 100%;
+    height: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  }
+
   &-receiver {
     flex: 0 0 auto;
 
+    &--muted {
+      background: var(--p-player-wrapper-background);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      overflow: hidden;
+    }
+
     &--sm {
       :deep(video) {
         border-radius: var(--p-player-cam-preview-sm-border-radius);
       }
+
+      &.video-call-receiver--muted {
+        border-radius: var(--p-player-cam-preview-sm-border-radius);
+      }
+
+      &.video-call-sender--muted {
+        padding-bottom: var(--p-player-control-bar-sm-height);
+      }
+
       width: var(--p-player-cam-preview-sm-width);
       height: var(--p-player-cam-preview-sm-height);
       position: relative;
@@ -119,6 +200,11 @@ const mainStream = computed(() => props.receiver || props.sender)
       :deep(video) {
         border-radius: var(--p-player-cam-preview-md-border-radius);
       }
+
+      &.video-call-receiver--muted {
+        border-radius: var(--p-player-cam-preview-md-border-radius);
+      }
+
       width: var(--p-player-cam-preview-md-width);
       height: var(--p-player-cam-preview-md-height);
       position: relative;
@@ -130,6 +216,11 @@ const mainStream = computed(() => props.receiver || props.sender)
       :deep(video) {
         border-radius: var(--p-player-cam-preview-lg-border-radius);
       }
+
+      &.video-call-receiver--muted {
+        border-radius: var(--p-player-cam-preview-lg-border-radius);
+      }
+
       width: var(--p-player-cam-preview-lg-width);
       height: var(--p-player-cam-preview-lg-height);
       position: relative;

package/types/components/wt-switcher/wt-switcher.vue.d.ts

@@ -7,28 +7,30 @@ interface Props extends ToggleSwitchProps {
     labelLeft?: boolean;
     disabled?: boolean;
     labelProps?: LabelProps;
+    controlled?: boolean;
 }
 type __VLS_Props = Props;
 type __VLS_PublicProps = __VLS_Props & {
     modelValue?: boolean;
 };
-declare var __VLS_9: {
+declare var __VLS_13: {
     label: string;
     value: any;
     disabled: boolean;
 };
 type __VLS_Slots = {} & {
-    label?: (props: typeof __VLS_9) => any;
+    label?: (props: typeof __VLS_13) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: boolean) => any;
+    "update:modelValue": (...args: any[]) => void;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: (value: boolean) => any;
+    "onUpdate:modelValue"?: (...args: any[]) => any;
 }>, {
     disabled: boolean;
     label: string;
     labelProps: LabelProps;
     labelLeft: boolean;
+    controlled: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/types/components/wt-vidstack-player/components/panels/video-call-controls-panel/video-call-controls-panel.vue.d.ts

@@ -1,18 +1,31 @@
+import { VideoCallAction } from '../../../../../modules/CallSession/modules/VideoCall/enums/VideoCallAction.enum';
 import { ScreenshotStatus } from '../../../../../modules/CallSession/types';
-interface Props {
-    recordings: boolean;
-    isMicMuted: boolean;
-    isVideoMuted: boolean;
-    isCallStarted: boolean;
-    screenshotIsLoading: boolean;
-    screenshotStatus: ScreenshotStatus | null;
-    screenshotCallback?: () => void;
-    recordingsCallback?: () => void;
-    micCallback?: () => void;
-    videoCallback?: () => void;
-    settingsCallback?: () => void;
-    chatCallback?: () => void;
-    callStateCallback?: () => void;
-}
-declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+import { ResultCallbacks } from '../../../../../types';
+type __VLS_Props = {
+    'actions': VideoCallAction[];
+    'mic:enabled': boolean;
+    'mic:accessed': boolean;
+    'video:enabled': boolean;
+    'video:accessed': boolean;
+    'screenshot:status': ScreenshotStatus | null;
+    'screenshot:loading': boolean;
+    'recordings': boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    chat: (payload?: unknown, options?: ResultCallbacks) => any;
+    video: (payload?: unknown, options?: ResultCallbacks) => any;
+    settings: (payload?: unknown, options?: ResultCallbacks) => any;
+    screenshot: (payload?: unknown, options?: ResultCallbacks) => any;
+    recordings: (payload?: unknown, options?: ResultCallbacks) => any;
+    mic: (payload?: unknown, options?: ResultCallbacks) => any;
+    hangup: (payload?: unknown, options?: ResultCallbacks) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChat?: (payload?: unknown, options?: ResultCallbacks) => any;
+    onVideo?: (payload?: unknown, options?: ResultCallbacks) => any;
+    onSettings?: (payload?: unknown, options?: ResultCallbacks) => any;
+    onScreenshot?: (payload?: unknown, options?: ResultCallbacks) => any;
+    onRecordings?: (payload?: unknown, options?: ResultCallbacks) => any;
+    onMic?: (payload?: unknown, options?: ResultCallbacks) => any;
+    onHangup?: (payload?: unknown, options?: ResultCallbacks) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/types/components/wt-vidstack-player/wt-vidstack-player.vue.d.ts

@@ -1,7 +1,8 @@
 import 'vidstack/player';
 import 'vidstack/player/ui';
+import { ComponentSize } from '../../enums';
 interface Props {
-    src: string | {
+    src?: string | {
         src: string;
         type?: string;
     };
@@ -12,12 +13,15 @@ interface Props {
     username?: string;
     closable?: boolean;
     resizable?: boolean;
+    staticPosition?: boolean;
     stream?: MediaStream;
+    componentSize?: keyof typeof ComponentSize;
+    hideDisplayPanel?: boolean;
 }
 declare var __VLS_24: {
-    size: "sm";
+    size: "sm" | "XXXS" | "XXS" | "XS" | "SM" | "MD" | "LG" | "XL" | "XXL" | "XXXL";
 }, __VLS_26: {
-    size: "sm";
+    size: "sm" | "XXXS" | "XXS" | "XS" | "SM" | "MD" | "LG" | "XL" | "XXL" | "XXXL";
 };
 type __VLS_Slots = {} & {
     'controls-panel'?: (props: typeof __VLS_24) => any;
@@ -36,7 +40,8 @@ declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {},
     closable: boolean;
     muted: boolean;
     resizable: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    staticPosition: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/types/modules/CallSession/index.d.ts

@@ -1,3 +1,3 @@
-import ScreenSharing from './modules/ScreenSharing/screen-sharing.vue';
-import VideoCall from './modules/VideoCall/video-call.vue';
-export { ScreenSharing, VideoCall };
+export { default as ScreenSharing } from './modules/ScreenSharing/screen-sharing.vue';
+export { VideoCallAction } from './modules/VideoCall/enums/VideoCallAction.enum';
+export { default as VideoCall } from './modules/VideoCall/video-call.vue';

package/types/modules/CallSession/modules/VideoCall/enums/VideoCallAction.enum.d.ts

@@ -0,0 +1,10 @@
+export declare const VideoCallAction: {
+    readonly Screenshot: "screenshot";
+    readonly Recordings: "recordings";
+    readonly Mic: "mic";
+    readonly Video: "video";
+    readonly Settings: "settings";
+    readonly Chat: "chat";
+    readonly Hangup: "hangup";
+};
+export type VideoCallAction = (typeof VideoCallAction)[keyof typeof VideoCallAction];

package/types/modules/CallSession/modules/VideoCall/video-call.vue.d.ts

@@ -1,20 +1,36 @@
+import { ResultCallbacks } from '../../../../types';
 import { ScreenshotStatus } from '../../types';
-interface Props {
-    sender: MediaStream;
-    receiver: MediaStream;
-    isMicMuted: boolean;
-    isVideoMuted: boolean;
-    isCallStarted: boolean;
-    recordings: boolean;
-    screenshotStatus: ScreenshotStatus | null;
-    screenshotIsLoading: boolean;
-    screenshotCallback?: () => void;
-    recordingsCallback?: () => void;
-    micCallback?: () => void;
-    videoCallback?: () => void;
-    settingsCallback?: () => void;
-    chatCallback?: () => void;
-    callStateCallback?: () => void;
-}
-declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+import { VideoCallAction } from './enums/VideoCallAction.enum';
+type __VLS_Props = {
+    'sender:stream'?: MediaStream | null;
+    'sender:mic:enabled'?: boolean;
+    'sender:mic:accessed'?: boolean;
+    'sender:video:enabled'?: boolean;
+    'sender:video:accessed'?: boolean;
+    'receiver:stream'?: MediaStream | null;
+    'receiver:mic:enabled'?: boolean;
+    'receiver:video:enabled'?: boolean;
+    'screenshot:status'?: ScreenshotStatus | null;
+    'screenshot:loading'?: boolean;
+    recordings?: boolean;
+    position?: 'static' | 'left' | 'right';
+    actions: VideoCallAction[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "action:screenshot": (payload?: unknown, options?: ResultCallbacks) => any;
+    "action:recordings": (payload?: unknown, options?: ResultCallbacks) => any;
+    "action:mic": (payload?: unknown, options?: ResultCallbacks) => any;
+    "action:video": (payload?: unknown, options?: ResultCallbacks) => any;
+    "action:settings": (payload?: unknown, options?: ResultCallbacks) => any;
+    "action:chat": (payload?: unknown, options?: ResultCallbacks) => any;
+    "action:hangup": (payload?: unknown, options?: ResultCallbacks) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onAction:screenshot"?: (payload?: unknown, options?: ResultCallbacks) => any;
+    "onAction:recordings"?: (payload?: unknown, options?: ResultCallbacks) => any;
+    "onAction:mic"?: (payload?: unknown, options?: ResultCallbacks) => any;
+    "onAction:video"?: (payload?: unknown, options?: ResultCallbacks) => any;
+    "onAction:settings"?: (payload?: unknown, options?: ResultCallbacks) => any;
+    "onAction:chat"?: (payload?: unknown, options?: ResultCallbacks) => any;
+    "onAction:hangup"?: (payload?: unknown, options?: ResultCallbacks) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/types/types/ResultCallbacks.types.d.ts

@@ -0,0 +1,5 @@
+export type ResultCallbacks = {
+    onSuccess?: () => void;
+    onError?: (error: Error) => void;
+    onComplete?: () => void;
+};

package/types/types/index.d.ts

@@ -0,0 +1 @@
+export type { ResultCallbacks } from './ResultCallbacks.types';