tas-uell-sdk 0.0.5 → 0.1.0

package/lib/components/tas-avatar/tas-avatar.component.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class TasAvatarComponent {
+    name: string;
+    size: number;
+    get initials(): string;
+    get fontSize(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TasAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TasAvatarComponent, "tas-avatar", never, { "name": "name"; "size": "size"; }, {}, never, never>;
+}

package/lib/components/tas-btn/tas-btn.component.d.ts

@@ -1,32 +1,52 @@
-import { OnInit, OnDestroy } from "@angular/core";
-import { NgbModal } from "@ng-bootstrap/ng-bootstrap";
-import { TasCurrentUser } from "../../interfaces/tas.interfaces";
-import { TasService } from "../../services/tas.service";
+import { OnInit, OnDestroy } from '@angular/core';
+import { NgbModal } from '@ng-bootstrap/ng-bootstrap';
+import { TasCurrentUser, TasRoomType, TasBusinessRole } from '../../interfaces/tas.interfaces';
+import { TasService } from '../../services/tas.service';
 import * as i0 from "@angular/core";
 export declare class TasButtonComponent implements OnInit, OnDestroy {
     private modalService;
     private tasService;
-    appointmentId: number;
-    product: string;
-    tenantId: string;
+    roomType: TasRoomType;
+    entityId: number;
+    tenant: string;
+    businessRole: TasBusinessRole;
     currentUser: TasCurrentUser;
-    ownerUserIds: number[];
-    regularUserIds: number[];
-    moderatorUserIds: number[];
-    /** Optional: If provided, skips room creation and goes directly to getting a token */
-    existingSessionId: string;
-    /** Optional: Custom button text */
-    buttonText: string;
+    variant: 'default' | 'teal';
+    buttonLabel: string;
     isLoading: boolean;
+    isCheckingStatus: boolean;
+    isStatusError: boolean;
+    statusErrorMessage: string;
+    isJoinable: boolean;
     private subscriptions;
     private currentModalRef;
     private videoCallModalRef;
+    private statusPollingInterval;
+    private readonly STATUS_POLL_INTERVAL_MS;
+    /** Whether user is backoffice (or admin/manager) */
+    get isBackoffice(): boolean;
+    /** Whether the button should be disabled */
+    get isDisabled(): boolean;
+    /** Reason why the button is disabled (for tooltip) */
+    get disabledReason(): string;
     constructor(modalService: NgbModal, tasService: TasService);
     ngOnInit(): void;
     ngOnDestroy(): void;
+    /**
+     * Start polling status every 30 seconds
+     */
+    private startStatusPolling;
+    /**
+     * Stop status polling
+     */
+    private stopStatusPolling;
+    /**
+     * Check status endpoint to determine if button should be enabled
+     */
+    private checkStatus;
     onClick(): void;
     private openWaitingRoomModal;
     private openVideoCallModal;
     static ɵfac: i0.ɵɵFactoryDeclaration<TasButtonComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TasButtonComponent, "tas-btn", never, { "appointmentId": "appointmentId"; "product": "product"; "tenantId": "tenantId"; "currentUser": "currentUser"; "ownerUserIds": "ownerUserIds"; "regularUserIds": "regularUserIds"; "moderatorUserIds": "moderatorUserIds"; "existingSessionId": "existingSessionId"; "buttonText": "buttonText"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TasButtonComponent, "tas-btn", never, { "roomType": "roomType"; "entityId": "entityId"; "tenant": "tenant"; "businessRole": "businessRole"; "currentUser": "currentUser"; "variant": "variant"; "buttonLabel": "buttonLabel"; }, {}, never, never>;
 }

package/lib/components/tas-floating-call/tas-floating-call.component.d.ts

@@ -1,18 +1,22 @@
 import { OnInit, OnDestroy } from '@angular/core';
+import { NgbModal } from '@ng-bootstrap/ng-bootstrap';
 import { TasService } from '../../services/tas.service';
 import * as i0 from "@angular/core";
 export declare class TasFloatingCallComponent implements OnInit, OnDestroy {
     private tasService;
+    private modalService;
     isVisible: boolean;
     isMuted: boolean;
     private subscriptions;
-    constructor(tasService: TasService);
+    private videoCallModalRef;
+    constructor(tasService: TasService, modalService: NgbModal);
     ngOnInit(): void;
     ngOnDestroy(): void;
     onExpand(): void;
     onHangUp(): void;
     toggleMute(): void;
     private setupSubscriptions;
+    private openVideoCallModal;
     private readonly PIP_MARGIN;
     private initInteract;
     static ɵfac: i0.ɵɵFactoryDeclaration<TasFloatingCallComponent, never>;

package/lib/components/tas-incoming-appointment/tas-incoming-appointment.component.d.ts

@@ -0,0 +1,33 @@
+import { OnInit, OnDestroy, EventEmitter } from '@angular/core';
+import { TasService } from '../../services/tas.service';
+import { TasAppointment, TasRoomType, TasBusinessRole, TasCurrentUser } from '../../interfaces/tas.interfaces';
+import * as i0 from "@angular/core";
+export declare class TasIncomingAppointmentComponent implements OnInit, OnDestroy {
+    private tasService;
+    roomType: TasRoomType;
+    entityId: number;
+    tenant: string;
+    businessRole: TasBusinessRole;
+    currentUser: TasCurrentUser;
+    enterCall: EventEmitter<TasAppointment>;
+    appointment: TasAppointment | null;
+    isLoading: boolean;
+    hasError: boolean;
+    private subscriptions;
+    constructor(tasService: TasService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private loadAppointments;
+    onEnterCall(): void;
+    /**
+     * Format date to Spanish format: "Lunes 8 de diciembre"
+     */
+    get formattedDate(): string;
+    /**
+     * Format time range: "9:00 - 9:30"
+     */
+    get formattedTimeRange(): string;
+    private formatDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TasIncomingAppointmentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TasIncomingAppointmentComponent, "tas-incoming-appointment", never, { "roomType": "roomType"; "entityId": "entityId"; "tenant": "tenant"; "businessRole": "businessRole"; "currentUser": "currentUser"; }, { "enterCall": "enterCall"; }, never, never>;
+}

package/lib/components/tas-videocall/tas-videocall.component.d.ts

@@ -1,21 +1,38 @@
 import { OnInit, OnDestroy, ElementRef, AfterViewInit } from '@angular/core';
 import { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap';
 import { TasService } from '../../services/tas.service';
-import { CallState } from '../../interfaces/tas.interfaces';
+import { GeolocationService } from '../../services/geolocation.service';
+import { CallState, TasBusinessRole, WaitingRoomUser } from '../../interfaces/tas.interfaces';
 import * as i0 from "@angular/core";
 export declare class TasVideocallComponent implements OnInit, OnDestroy, AfterViewInit {
     activeModal: NgbActiveModal;
     private tasService;
+    private geolocationService;
     sessionId: string;
     token: string;
+    appointmentId?: number;
+    videoCallId?: number;
+    userId?: number;
+    participantName: string;
+    tenant: string;
+    businessRole: TasBusinessRole;
     isReturningFromPip: boolean;
     publisherContainer: ElementRef;
     subscriberContainer: ElementRef;
     isPublisherSmall: boolean;
     callState: CallState;
     isMuted: boolean;
+    waitingRoomUsers: WaitingRoomUser[];
+    ownerHasJoined: boolean;
+    hasVideoStream: boolean;
+    dismissedUsers: number[];
+    showLocationPanel: boolean;
+    userHasLocation: boolean;
+    geoLocationStatus: 'unknown' | 'active' | 'denied';
+    geoRequestActive: boolean;
+    allGeoGranted: boolean;
     private subscriptions;
-    constructor(activeModal: NgbActiveModal, tasService: TasService);
+    constructor(activeModal: NgbActiveModal, tasService: TasService, geolocationService: GeolocationService);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
@@ -24,10 +41,39 @@ export declare class TasVideocallComponent implements OnInit, OnDestroy, AfterVi
     minimize(): void;
     toggleSwap(): void;
     onDoubleClick(): void;
+    /**
+     * Check if current user can admit others (OWNER, BACKOFFICE, or MODERATOR)
+     */
+    get canAdmitUsers(): boolean;
+    /**
+     * Admit a user from the waiting room
+     */
+    admitUser(userId: number): void;
+    /**
+     * Dismiss the waiting room notification for a user
+     */
+    dismissWaitingNotification(userId: number): void;
+    /**
+     * Close the location panel
+     */
+    closeLocationPanel(): void;
+    /**
+     * Request the user to share their location
+     */
+    requestUserLocation(): void;
     private setupSubscriptions;
+    /**
+     * Handle activateGeo request from backend (for non-owner users).
+     * If geo is already active, report it. If not, prompt user.
+     */
+    private handleActivateGeo;
+    /**
+     * Report geolocation status to backend.
+     */
+    private reportGeoStatus;
     private initializeCall;
     private resetVideoPositions;
     private initInteract;
     static ɵfac: i0.ɵɵFactoryDeclaration<TasVideocallComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TasVideocallComponent, "tas-videocall", never, { "sessionId": "sessionId"; "token": "token"; "isReturningFromPip": "isReturningFromPip"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TasVideocallComponent, "tas-videocall", never, { "sessionId": "sessionId"; "token": "token"; "appointmentId": "appointmentId"; "videoCallId": "videoCallId"; "userId": "userId"; "participantName": "participantName"; "tenant": "tenant"; "businessRole": "businessRole"; "isReturningFromPip": "isReturningFromPip"; }, {}, never, never>;
 }

package/lib/components/tas-waiting-room/tas-waiting-room.component.d.ts

@@ -1,63 +1,80 @@
-import { OnInit, OnDestroy } from '@angular/core';
+import { OnInit, OnDestroy, ChangeDetectorRef } from '@angular/core';
 import { NgbActiveModal, NgbModal } from '@ng-bootstrap/ng-bootstrap';
 import { TasService } from '../../services/tas.service';
-import { TasCurrentUser } from '../../interfaces/tas.interfaces';
+import { GeolocationService } from '../../services/geolocation.service';
+import { TasCurrentUser, TasRoomType, TasBusinessRole } from '../../interfaces/tas.interfaces';
 import * as i0 from "@angular/core";
 export declare enum WaitingRoomState {
-    IDLE = "IDLE",
-    CREATING_ROOM = "CREATING_ROOM",
-    GETTING_TOKEN = "GETTING_TOKEN",
+    CHECKING_STATUS = "CHECKING_STATUS",
+    WAITING_FOR_JOINABLE = "WAITING_FOR_JOINABLE",
     READY = "READY",
+    GETTING_TOKEN = "GETTING_TOKEN",
+    JOINING = "JOINING",
     ERROR = "ERROR"
 }
 export declare class TasWaitingRoomComponent implements OnInit, OnDestroy {
     activeModal: NgbActiveModal;
     private tasService;
+    private geolocationService;
     private modalService;
-    appointmentId: number;
-    product: string;
-    tenantId: string;
+    private cdr;
+    roomType: TasRoomType;
+    entityId: number;
+    tenant: string;
+    businessRole: TasBusinessRole;
     currentUser: TasCurrentUser;
-    ownerUserIds: number[];
-    regularUserIds: number[];
-    moderatorUserIds: number[];
-    /** Optional: If provided, skips room creation and goes directly to getting a token */
-    existingSessionId: string;
     state: WaitingRoomState;
     WaitingRoomState: typeof WaitingRoomState;
     errorMessage: string;
-    /** Whether we have an existing session (passed via input) */
-    hasExistingSession: boolean;
-    /** UI toggle: show "Join Existing" input vs "Create New" */
-    showJoinExistingUI: boolean;
-    /** Manual session ID input by user */
-    manualSessionId: string;
-    /** Track if we're joining an existing session (for UI display) */
-    isJoiningExisting: boolean;
-    private sessionId;
+    isJoinable: boolean;
+    private resolvedSessionId;
+    private resolvedAppointmentId;
     private token;
-    private users;
+    private videoCallId;
     private subscriptions;
     private videoCallModalRef;
-    constructor(activeModal: NgbActiveModal, tasService: TasService, modalService: NgbModal);
+    private geoPosition;
+    /** Whether current user is an owner */
+    get isOwner(): boolean;
+    constructor(activeModal: NgbActiveModal, tasService: TasService, geolocationService: GeolocationService, modalService: NgbModal, cdr: ChangeDetectorRef);
     ngOnInit(): void;
-    ngOnDestroy(): void;
     /**
-     * Creates the room and fetches the token (new session flow)
+     * Request camera and microphone permissions.
+     */
+    private requestMediaPermissions;
+    /**
+     * Request geolocation immediately on init.
+     * Only for regular users (not owners/backoffice).
+     * If user allows, store position and send to backend.
+     */
+    private requestGeolocation;
+    /**
+     * Send geolocation to backend via modify user endpoint.
+     * NOTE: Endpoint call is prepared but may not be active yet.
      */
-    createRoom(): void;
+    private sendGeolocationToBackend;
+    ngOnDestroy(): void;
     /**
-     * Join existing room with manually entered session ID
+     * Check status to get session info
      */
-    joinExistingWithManualId(): void;
+    private checkStatus;
     /**
-     * Gets a token for an existing session (existing session flow)
+     * Handle changes to joinable status
      */
-    getTokenForExistingSession(): void;
+    private handleJoinableChange;
     /**
-     * Joins the video call session
+     * Called when user clicks the join button.
+     * Calls /start to get token then auto-joins.
      */
     joinSession(): void;
+    /**
+     * Check if user has owner/backoffice role
+     */
+    private get isBackoffice();
+    /**
+     * Start session and join - called when user clicks join button
+     */
+    private startSessionAndJoin;
     /**
      * Closes the waiting room
      */
@@ -66,9 +83,7 @@ export declare class TasWaitingRoomComponent implements OnInit, OnDestroy {
      * Retry after an error
      */
     retry(): void;
-    private buildUsersArray;
-    private setupViewModeSubscription;
     private openVideoCallModal;
     static ɵfac: i0.ɵɵFactoryDeclaration<TasWaitingRoomComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TasWaitingRoomComponent, "tas-waiting-room", never, { "appointmentId": "appointmentId"; "product": "product"; "tenantId": "tenantId"; "currentUser": "currentUser"; "ownerUserIds": "ownerUserIds"; "regularUserIds": "regularUserIds"; "moderatorUserIds": "moderatorUserIds"; "existingSessionId": "existingSessionId"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TasWaitingRoomComponent, "tas-waiting-room", never, { "roomType": "roomType"; "entityId": "entityId"; "tenant": "tenant"; "businessRole": "businessRole"; "currentUser": "currentUser"; }, {}, never, never>;
 }

package/lib/config/tas.config.d.ts

@@ -13,10 +13,17 @@ export interface TasConfig {
  * HTTP client interface that consuming apps must implement
  */
 export interface TasHttpClient {
+    get<T>(url: string, options: {
+        headers?: Record<string, string>;
+    }): Observable<T>;
     post<T>(url: string, options: {
         body: any;
         headers?: Record<string, string>;
     }): Observable<T>;
+    patch<T>(url: string, options: {
+        body: any;
+        headers?: Record<string, string>;
+    }): Observable<T>;
 }
 /**
  * Injection token for TAS configuration

package/lib/interfaces/tas.interfaces.d.ts

@@ -1,32 +1,8 @@
-export interface CreateRoomUser {
-    userExternalId: number;
-    rol: TasUserRole;
-}
-export interface CreateRoomRequest {
-    roomType: TasRoomType;
-    type: TasSessionType;
-    utcScheduled?: string;
-    product: string;
-    tenant: string;
-    appointmentId: number;
-    users: CreateRoomUser[];
-}
-export interface CreateRoomResponse {
-    content: {
-        roomType: string | null;
-        tenant: string | null;
-        user_id: string | null;
-        product: string | null;
-        record: boolean | null;
-        sessionId: string;
-        roomId: number;
-        status: TasSessionType;
-    };
-}
 export declare enum TasRoomType {
     TAS = "TAS",
     JM = "JM",
-    WEBINAR = "WEBINAR"
+    WEBINAR = "WEBINAR",
+    WELLNESS_MANAGER = "WELLNESS_MANAGER"
 }
 export declare enum TasSessionType {
     SPONTANEOUS = "SPONTANEOUS",
@@ -37,11 +13,69 @@ export declare enum TasUserRole {
     USER = "USER",
     MODERATOR = "MODERATOR"
 }
+export declare enum TasBusinessRole {
+    ADMIN_MANAGER = "ADMIN_MANAGER",
+    MANAGER = "MANAGER",
+    BACKOFFICE = "BACKOFFICE",
+    USER = "USER"
+}
+export declare enum VideoSessionStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    PENDING = "PENDING",
+    SCHEDULED = "SCHEDULED"
+}
+export declare enum UserStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    ASSIGNED = "ASSIGNED"
+}
+export declare enum UserCallAction {
+    WAITING_ROOM_ENTER = "WAITING_ROOM_ENTER",
+    WAITING_ROOM_LEAVE = "WAITING_ROOM_LEAVE",
+    BAN = "BAN",
+    CHANGE_STATUS = "CHANGE_STATUS",
+    REQUEST_GEOLOCALIZATION = "REQUEST_GEOLOCALIZATION",
+    ACTIVATE_GEOLOCATION = "ACTIVATE_GEOLOCATION"
+}
+export declare enum RoomUserStatus {
+    ASSIGNED = "ASSIGNED",
+    WAITING = "WAITING",
+    JOINED = "JOINED",
+    FINISHED = "FINISHED"
+}
+export declare enum CallState {
+    IDLE = "IDLE",
+    CONNECTING = "CONNECTING",
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED",
+    ERROR = "ERROR"
+}
+export declare enum ViewMode {
+    FULLSCREEN = "FULLSCREEN",
+    PIP = "PIP"
+}
 export interface TasCurrentUser {
+    id: number;
     name: string;
     lastname: string;
     role: TasUserRole;
 }
+/** Input configuration for the TAS video call library */
+export interface TasCallConfig {
+    appointmentId?: number;
+    sessionId?: string;
+    roomType: TasRoomType;
+    entityId: number;
+    tenant: string;
+    businessRole: TasBusinessRole;
+    currentUser: TasCurrentUser;
+}
+export interface StartSessionRequest {
+    sessionId: string;
+    name: string;
+    lastname: string;
+}
 export interface GenerateTokenRequest {
     sessionId: string;
     name: string;
@@ -53,14 +87,72 @@ export interface GenerateTokenResponse {
         token: string;
     };
 }
-export declare enum CallState {
-    IDLE = "IDLE",
-    CONNECTING = "CONNECTING",
-    CONNECTED = "CONNECTED",
-    DISCONNECTED = "DISCONNECTED",
-    ERROR = "ERROR"
+export interface ProxyVideoStatusRequest {
+    appointmentId?: number;
+    businessRole?: TasBusinessRole;
+    tenant?: string;
+    sessionId?: string;
+    roomType?: TasRoomType;
+    entityId?: number;
 }
-export declare enum ViewMode {
-    FULLSCREEN = "FULLSCREEN",
-    PIP = "PIP"
+export interface ProxyVideoStatusUser {
+    userId: number;
+    rol: TasUserRole;
+    status: UserStatus;
+}
+export interface ProxyVideoStatusResponse {
+    content: {
+        videoCallId: number;
+        sessionId: string;
+        statusVL: VideoSessionStatus;
+        joinable: boolean;
+        waitingRoomAvailable: boolean;
+        appointmentId: number;
+        activateGeo: boolean;
+        geoRequestActive?: boolean;
+        allGeoGranted?: boolean;
+        users: ProxyVideoStatusUser[];
+    };
+}
+export interface ProxyVideoFinishRequest {
+    sessionId: string;
+    businessRole: TasBusinessRole;
+}
+export interface FinishSessionResponse {
+    content: {
+        message: string;
+        callStatus: string;
+    };
+}
+export interface ProxyVideoUserModifyRequest {
+    userId?: number;
+    videoCallId: number;
+    action?: UserCallAction;
+    newStatus?: RoomUserStatus;
+    latitude?: number;
+    longitude?: number;
+}
+export interface WaitingRoomUser {
+    userId: number;
+    name: string;
+    status: RoomUserStatus;
+}
+export declare enum AppointmentStatus {
+    CONFIRMED = "CONFIRMED",
+    CANCELLED = "CANCELLED"
+}
+export interface TasAppointment {
+    id: number;
+    agendaId: number;
+    date: string;
+    startTime: string;
+    endTime: string;
+    bookingType: string;
+    status: AppointmentStatus;
+    title: string;
+    notes: string;
+}
+export interface GetAppointmentsRequest {
+    fromDate: string;
+    toDate: string;
 }

package/lib/services/geolocation.service.d.ts

@@ -0,0 +1,24 @@
+import * as i0 from "@angular/core";
+export interface GeoPosition {
+    latitude: number;
+    longitude: number;
+}
+export declare class GeolocationService {
+    private cachedPosition;
+    /**
+     * Request current geolocation position using Web Geolocation API.
+     * Works in both browser and Capacitor environments.
+     * @returns Promise with {latitude, longitude} or null if denied/unavailable
+     */
+    getCurrentPosition(): Promise<GeoPosition | null>;
+    /**
+     * Get the cached position from the last successful request.
+     */
+    getCachedPosition(): GeoPosition | null;
+    /**
+     * Clear the cached position.
+     */
+    clearCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeolocationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GeolocationService>;
+}