@veltdev/types 4.7.2 → 4.7.4

package/app/models/data/reaction.data.model.d.ts

@@ -0,0 +1,18 @@
+import { User } from "./user.data.model";
+export declare class Reaction {
+    /**
+     * Emoji variant.
+     */
+    variant?: string;
+    /**
+     * The user who added reaction.
+     *
+     */
+    from: User;
+    /**
+     * Timestamp when this reaction was added.
+     *
+     * Auto generated.
+     */
+    lastUpdated?: Date;
+}

package/app/models/data/recorder-annotation.data.model.d.ts

@@ -1,18 +1,24 @@
-import { RecorderBoundedScaleRange } from "src/models";
+import { RecorderFileFormat, RecorderLayoutMode, RecorderType } from "../../utils/enums";
 import { Attachment } from "./attachment.model";
+import { BaseMetadata } from "./base-metadata.data.model";
 import { CursorPosition } from "./cursor-position.data.model";
 import { Location } from "./location.model";
 import { PageInfo } from "./page-info.model";
 import { TargetElement } from "./target-element.data.model";
 import { Transcription } from "./transcription.data.model";
-import { User } from "./user.data.model";
+import { Context, User } from "./user.data.model";
 export declare class RecorderAnnotation {
+    context?: Context;
     /**
      * Unique identifier for the recorder pin annotation.
      *
      * Auto generated.
      */
     annotationId: string;
+    /**
+       * Connected comment annotation id of reaction annotation
+       */
+    commentAnnotationId?: string;
     /**
      * The user who created this recorder pin annotation.
      *
@@ -88,8 +94,8 @@ export declare class RecorderAnnotation {
      */
     location?: Location | null;
     type?: string;
-    recordingType: string;
-    mode: 'floating' | 'thread';
+    recordingType: RecorderType;
+    mode: RecorderLayoutMode;
     approved?: boolean;
     /**
      * Attachment object of recorded media
@@ -118,30 +124,116 @@ export declare class RecorderAnnotation {
      * Transcription of the recorded media
      */
     transcription?: Transcription;
+    /**
+     * Waveform data for the annotation
+     */
+    waveformData?: number[];
+    /**
+     * Display name for the annotation
+     */
+    displayName?: string;
+    metadata?: RecorderMetadata;
     /**
      * Current version of the recording edit
      */
     latestVersion?: number;
     /**
      * History of all editing versions of this recording
+     * Maps version number to version data
      */
-    recordingEditVersions?: { [key: number]: RecorderAnnotationEditVersion };
+    recordingEditVersions?: {
+        [key: number]: RecorderAnnotationEditVersion;
+    };
+    /**
+     * URLs for individual uploaded chunks
+     */
+    chunkUrls?: {
+        [key: number]: string;
+    };
 }
-
 export interface RecorderAnnotationEditVersion {
     from?: User;
     createdAt?: Date;
     attachment?: Attachment | null;
     attachments?: Attachment[];
-    recordedTime?: { duration?: number, display?: string } | null;
+    recordedTime?: {
+        duration?: number;
+        display?: string;
+    } | null;
     transcription?: Transcription;
     waveformData?: number[];
     displayName?: string;
     boundedTrimRanges?: RecorderBoundedTrimRange[];
     boundedScaleRanges?: RecorderBoundedScaleRange[];
 }
-
 export interface RecorderBoundedTrimRange {
     start: number;
     end: number;
-}
+}
+export interface RecorderBoundedScaleRange {
+    start: number;
+    end: number;
+    zoomInDuration?: number;
+    holdDuration?: number;
+    zoomOutDuration?: number;
+    zoomFactor?: number;
+    centerX?: number;
+    centerY?: number;
+    topLeftX?: number;
+    topLeftY?: number;
+    topLeftXPixels?: number;
+    topLeftYPixels?: number;
+}
+export interface RecorderEditRange {
+    trimRanges: RecorderBoundedTrimRange[];
+    scaleRanges: RecorderBoundedScaleRange[];
+}
+export declare class RecorderMetadata extends BaseMetadata {
+    [key: string]: any;
+}
+declare class RecorderDataTranscriptSegment {
+    startTime: string;
+    endTime: string;
+    startTimeInSeconds: number;
+    endTimeInSeconds: number;
+    text: string;
+}
+declare class RecorderDataTranscription {
+    transcriptSegments?: RecorderDataTranscriptSegment[];
+    vttFileUrl?: string;
+    contentSummary?: string;
+}
+declare class RecorderDataAsset {
+    version?: number;
+    url: string;
+    mimeType?: string;
+    fileName?: string;
+    /** File size in bytes */
+    fileSizeInBytes?: number;
+    /**
+     * The format/extension of the file
+     * @example 'mp3', 'mp4', 'webm'
+     */
+    fileFormat?: RecorderFileFormat;
+    thumbnailUrl?: string;
+    transcription: RecorderDataTranscription;
+}
+export declare class RecorderData {
+    recorderId: string;
+    from?: User | null;
+    metadata?: RecorderMetadata;
+    assets: RecorderDataAsset[];
+    assetsAllVersions: RecorderDataAsset[];
+    transcription: RecorderDataTranscription;
+}
+export interface RecorderRequestQuery {
+    recorderIds: string[];
+}
+export interface GetRecordingDataResponse {
+    data: Record<string, RecorderData> | null;
+}
+export interface GetRecordingsResponse extends RecorderData {
+}
+export interface DeleteRecordingsResponse extends RecorderData {
+}
+export {};

package/app/models/data/recorder-events.data.model.d.ts

@@ -0,0 +1,45 @@
+import { RecorderData } from "../../models/data/recorder-annotation.data.model";
+import { RecorderEventTypes } from "../../utils/enums";
+export interface TranscriptionDoneEvent extends RecorderData {
+}
+export interface RecordingDoneEvent extends RecorderData {
+}
+export interface RecordingDeleteEvent extends RecorderData {
+}
+export interface RecordingEditDoneEvent extends RecorderData {
+}
+export interface RecordingActionsEvent {
+    type: 'audio' | 'video' | 'screen';
+}
+export interface RecordingStartedEvent extends RecordingActionsEvent {
+}
+export interface RecordingPausedEvent extends RecordingActionsEvent {
+}
+export interface RecordingCancelledEvent extends RecordingActionsEvent {
+}
+export interface RecordingStoppedEvent extends RecordingActionsEvent {
+}
+export interface RecordingResumedEvent extends RecordingActionsEvent {
+}
+export interface RecordingErrorEvent {
+    type: string;
+    message: string;
+    recorderId?: string;
+    url?: string;
+}
+export interface RecordingSaveInitiatedEvent {
+    annotationId?: string;
+    message: string;
+    type: 'edit' | 'record';
+}
+export type RecorderEventTypesMap = {
+    [RecorderEventTypes.TRANSCRIPTION_DONE]: TranscriptionDoneEvent;
+    [RecorderEventTypes.RECORDING_DONE]: RecordingDoneEvent;
+    [RecorderEventTypes.RECORDING_EDIT_DONE]: RecordingEditDoneEvent;
+    [RecorderEventTypes.DELETE_RECORDING]: RecordingDeleteEvent;
+    [RecorderEventTypes.RECORDING_STARTED]: RecordingStartedEvent;
+    [RecorderEventTypes.RECORDING_PAUSED]: RecordingPausedEvent;
+    [RecorderEventTypes.RECORDING_CANCELLED]: RecordingCancelledEvent;
+    [RecorderEventTypes.RECORDING_STOPPED]: RecordingStoppedEvent;
+    [RecorderEventTypes.RECORDING_RESUMED]: RecordingResumedEvent;
+};

package/app/models/data/recorder.model.d.ts

@@ -1,4 +1,5 @@
 import { Observable } from "rxjs";
+import { RecorderType } from "../../utils/enums";
 export declare class RecorderConfig {
     type: {
         audio?: boolean;
@@ -26,7 +27,7 @@ export declare class RecorderInitData {
     /**
      * Type of media recorder, possible values are 'audio', 'video' and 'screen'
      */
-    type: 'audio' | 'video' | 'screen';
+    type: RecorderType;
     /**
      * Observable of recorded raw data.
      */
@@ -44,7 +45,7 @@ export declare class RecordedRawData {
     /**
      * Type of recorded data, possible values are 'audio' and 'video'
      */
-    type: 'audio' | 'video' | 'screen';
+    type: RecorderType;
     /**
      * Base64 encoded string of thumbnail image of one frame of recorded video
      */
@@ -56,6 +57,12 @@ export declare class RecordedRawData {
         duration?: number;
         display?: string;
     } | null;
+    /**
+     * Array of URLs for individual uploaded chunks
+     */
+    chunkUrls?: {
+        [key: number]: string;
+    };
 }
 export declare class RecordedData {
     /**
@@ -78,5 +85,27 @@ export declare class RecordedData {
      * URL of the hosted website to open video in new tab
      */
     videoPlayerUrl?: string;
+    /**
+     * URLs for individual uploaded chunks
+     */
+    chunkUrls?: {
+        [key: number]: string;
+    };
     getThumbnailTag: (url?: string) => string;
 }
+export declare class RecorderQualityConstraintsOptions {
+    video?: MediaTrackConstraints;
+    audio?: MediaTrackConstraints;
+}
+export declare class RecorderQualityConstraints {
+    safari?: RecorderQualityConstraintsOptions;
+    other?: RecorderQualityConstraintsOptions;
+}
+export declare class RecorderEncodingOptions {
+    safari?: MediaRecorderOptions;
+    other?: MediaRecorderOptions;
+}
+export declare class RecorderDevicePermissionOptions {
+    audio?: boolean;
+    video?: boolean;
+}

package/app/models/data/resolver.data.model.d.ts

@@ -0,0 +1,36 @@
+export interface ResolverEndpointConfig {
+    url: string;
+    headers?: Record<string, string>;
+}
+export interface ResolverConfig {
+    resolveTimeout?: number;
+    saveRetryConfig?: RetryConfig;
+    deleteRetryConfig?: RetryConfig;
+    getRetryConfig?: RetryConfig;
+    resolveUsersConfig?: ResolveUsersConfig;
+    fieldsToRemove?: string[];
+    getConfig?: ResolverEndpointConfig;
+    saveConfig?: ResolverEndpointConfig;
+    deleteConfig?: ResolverEndpointConfig;
+}
+export interface ResolveUsersConfig {
+    organization?: boolean;
+    folder?: boolean;
+    document?: boolean;
+}
+export interface ResolverResponse<T> {
+    data?: T;
+    success: boolean;
+    message?: string;
+    timestamp?: number;
+    statusCode: number;
+}
+export interface RetryConfig {
+    retryCount?: number;
+    retryDelay?: number;
+    revertOnFailure?: boolean;
+}
+export interface ResolverResponseConfig {
+    revertOnFailure?: boolean;
+    isSuccess?: boolean;
+}

package/app/models/data/screenshot.data.model.d.ts

@@ -0,0 +1,10 @@
+import { AreaAnnotation } from "./area-annotation.data.model";
+import { CommentAnnotation } from "./comment-annotation.data.model";
+export interface ScreenshotData {
+    source?: string;
+    sourceData?: {
+        commentAnnotation?: CommentAnnotation;
+        areaAnnotation?: AreaAnnotation;
+    };
+    eventType: string;
+}

package/app/models/data/selection.model.d.ts

@@ -19,4 +19,16 @@ export declare class Selection {
      */
     targetTextRange?: TargetTextRange | null;
     pageInfo: PageInfo;
+    timestamp: number;
+}
+export declare enum UserIndicatorPosition {
+    Start = "start",
+    End = "end"
+}
+export declare enum UserIndicatorType {
+    Avatar = "avatar",
+    Label = "label"
+}
+export declare class LiveSelectionData {
+    [userIdHash: string]: Selection;
 }

package/app/models/data/sync-video-player.data.model.d.ts

@@ -0,0 +1,47 @@
+import { User } from "./user.data.model";
+export declare class SyncVideoPlayer {
+    /**
+     * The id of the player
+     */
+    playerId?: string;
+    src?: string;
+    sources?: string[];
+    /**
+     * Last updated timestamp
+     */
+    lastUpdated?: number;
+    /**
+     * Last updated by user
+     */
+    lastUpdatedBy?: User;
+    /**
+     * Last updated event
+     */
+    lastUpdatedEvent?: string;
+    /**
+     * The state of the player
+     */
+    playerState: SyncVideoPlayerState;
+}
+export declare class SyncVideoPlayerState {
+    /**
+     * True if the video is playing
+     */
+    playing?: boolean;
+    /**
+     * Current time of the video
+     */
+    currentTime?: number;
+    /**
+     * True if the video is muted
+     */
+    muted?: boolean;
+    /**
+     * Volume of the video
+     */
+    volume?: number;
+    /**
+     * Playback rate of the video
+     */
+    speed?: number;
+}

package/app/models/data/target-element.data.model.d.ts

@@ -1,3 +1,4 @@
+import { AnchorRecord } from './anchor-record.data.model';
 export declare class TargetElement {
     /**
      * Xpath of target element
@@ -19,4 +20,8 @@ export declare class TargetElement {
      * Relative left position of cursor on target element
      */
     leftPercentage: number;
+    /**
+     * Robust anchor descriptor for the element
+     */
+    anchor?: AnchorRecord | null;
 }

package/app/models/data/target-text-range.data.model.d.ts

@@ -1,8 +1,21 @@
+import { AnchorRecord } from "./anchor-record.data.model";
 export declare class TargetTextRange {
     /**
      * Xpath of common Ancestor Container
      */
     commonAncestorContainer?: string;
+    /**
+     * Full xpath of common Ancestor Container
+     */
+    commonAncestorContainerFXpath?: string;
+    /**
+     * Full xpath of common Ancestor Container with class names
+     */
+    commonAncestorContainerCFXpath?: string;
+    /**
+     * Anchor of common Ancestor Container
+     */
+    commonAncestorContainerAnchor?: AnchorRecord;
     /**
      * Selected text
      */

package/app/models/data/user-contact.data.model.d.ts

@@ -26,4 +26,25 @@ export declare class UserContact {
     groupId?: string;
     source?: string;
     visibility: 'group' | 'private';
+    color?: string;
+    textColor?: string;
+    initial?: string;
+}
+export declare class SelectedUserContact {
+    /**
+     * Selected user contact details.
+     */
+    contact: UserContact;
+    /**
+     * Is user part of organization contact.
+     */
+    isOrganizationContact: boolean;
+    /**
+     * Is user part of document contact.
+     */
+    isDocumentContact: boolean;
+    /**
+     * Document access type.
+     */
+    documentAccessType: string;
 }

package/app/models/data/user-iam.data.model.d.ts

@@ -1,3 +1,4 @@
+import { BaseMetadata } from "./base-metadata.data.model";
 import { UserContact } from "./user-contact.data.model";
 import { UserRole } from "./user-role.data.model";
 import { User } from "./user.data.model";
@@ -10,6 +11,16 @@ export declare class UserIAM {
      * The user's contact details
      */
     user: UserContact;
+    accessFields?: string[];
+    documentIds?: string[];
+    viewerDocumentIds?: string[];
+    folderIds?: string[];
+    viewerFolderIds?: string[];
+    organizationIds?: string[];
+    viewerOrganizationIds?: string[];
+    documentIdsCount?: number;
+    folderIdsCount?: number;
+    organizationIdsCount?: number;
     /**
      * The user's role in the document
      */
@@ -30,4 +41,8 @@ export declare class UserIAM {
      * Date when this user was updated
      */
     updatedDate?: any;
+    groups?: {
+        [groupId: string]: boolean;
+    };
+    metadata?: BaseMetadata;
 }

package/app/models/data/user-organization.data.model.d.ts

@@ -0,0 +1,12 @@
+import { OrganizationUserGroup } from "./organization-groups.data.model";
+import { OrganizationMetadata } from "./organization-metadata.model";
+export declare class UserOrganization {
+    /**
+     * User organization metadata.
+     */
+    metadata?: OrganizationMetadata;
+    /**
+     * User organization groups.
+     */
+    groups?: OrganizationUserGroup[];
+}

package/app/models/data/user-resolver.data.model.d.ts

@@ -0,0 +1,56 @@
+import { ResolverConfig } from "./resolver.data.model";
+import { User } from "./user.data.model";
+export interface UserDataProvider {
+    get(userIds: string[]): Promise<Record<string, User>>;
+    config?: ResolverConfig;
+    resolveTimeout?: number;
+}
+export interface GetUserResolverRequest {
+    organizationId: string;
+    userIds: string[];
+}
+export interface GetUserPermissionsRequest {
+    organizationId?: string;
+    folderIds?: string[];
+    documentIds?: string[];
+}
+export interface GetUserPermissionsResponse {
+    [userId: string]: {
+        folders?: {
+            [folderId: string]: {
+                accessRole?: UserPermissionAccessRole;
+                expiresAt?: number;
+                error?: string;
+                errorCode?: UserPermissionAccessRoleResult;
+            };
+        };
+        organization?: {
+            [organizationId: string]: {
+                accessRole?: UserPermissionAccessRole;
+                expiresAt?: number;
+                error?: string;
+                errorCode?: UserPermissionAccessRoleResult;
+            };
+        };
+        documents?: {
+            [documentId: string]: {
+                accessRole?: UserPermissionAccessRole;
+                expiresAt?: number;
+                error?: string;
+                errorCode?: UserPermissionAccessRoleResult;
+            };
+        };
+        context?: {
+            accessFields?: Array<string>;
+        };
+    };
+}
+export declare enum UserPermissionAccessRole {
+    EDITOR = "editor",
+    VIEWER = "viewer"
+}
+export declare enum UserPermissionAccessRoleResult {
+    DOES_NOT_EXIST = "does_not_exist",
+    PERMISSION_DENIED = "permission_denied",
+    SOMETHING_WENT_WRONG = "something_went_wrong"
+}

package/app/models/data/user.data.model.d.ts

@@ -1,4 +1,6 @@
+import { SetDocumentsContext } from "./document.data.model";
 import { UserContact } from "./user-contact.data.model";
+import { UserPermissionAccessRole } from "./user-resolver.data.model";
 export declare class User {
     /**
      * Unique user identifier that you use to identify your user.
@@ -10,6 +12,7 @@ export declare class User {
      * Default: Random avatar name.
      */
     name?: string;
+    clientUserName?: string;
     /**
     * Your user's display picture URL.
     *
@@ -37,6 +40,8 @@ export declare class User {
      * Original groupId provided by the user.
      */
     clientGroupId?: string;
+    organizationId?: string;
+    clientOrganizationId?: string;
     /**
      * Auto generated unique user id that is linked with your app's user ID.
      * This is needed by us for internal processing.
@@ -47,6 +52,10 @@ export declare class User {
      * This is the color on the avatar border and live cursor, if these features are enabled.
      */
     color?: string;
+    /**
+     * This is the color on the avatar text.
+     */
+    textColor?: string;
     /**
      * User type.
      *
@@ -65,6 +74,7 @@ export declare class User {
      * Guest user
      */
     isGuest?: boolean;
+    initial?: string;
 }
 export declare class Options {
     /**
@@ -86,4 +96,76 @@ export declare class Options {
      * Pass the auth token of the user.
      */
     authToken?: string;
+    /**
+     * If you want to force re-login the user.
+     */
+    forceReset?: boolean;
+    /**
+     * If you want to throw an error if the user is not authenticated.
+     */
+    throwError?: boolean;
+}
+export interface AuthRetryConfig {
+    retryCount?: number;
+    retryDelay?: number;
+}
+export interface Context {
+    access: {
+        [key: string]: string | number;
+    };
+    accessFields?: Array<string>;
+}
+export interface VeltAuthProvider {
+    user: User;
+    options?: Options;
+    retryConfig?: AuthRetryConfig;
+    generateToken?: () => Promise<string>;
+    onError?: (err: unknown) => void;
+}
+export declare enum RevokeAccessOnType {
+    DOCUMENT_UNSET = "document_unset",
+    USER_LOGOUT = "user_logout"
+}
+export declare enum PermissionSource {
+    SET_DOCUMENTS = "setDocuments",
+    IDENTIFY = "identify",
+    GET_NOTIFICATIONS = "getNotifications",
+    SET_NOTIFICATIONS = "setNotifications",
+    REVOKE_ACCESS_ON_USER_LOGOUT = "revokeAccessOnUserLogout",
+    REVOKE_ACCESS_ON_DOCUMENT_UNSET = "revokeAccessOnDocumentUnset"
+}
+export interface RevokeAccessOn {
+    type: RevokeAccessOnType;
+    revokeOrganizationAccess?: boolean;
+}
+export interface VeltPermissionProvider {
+    retryConfig?: AuthRetryConfig;
+    isContextEnabled?: boolean;
+    revokeAccessOn?: RevokeAccessOn[];
+    forceRefresh?: boolean;
+}
+export declare enum PermissionResourceType {
+    FOLDER = "folder",
+    DOCUMENT = "document",
+    ORGANIZATION = "organization",
+    CONTEXT = "context"
+}
+export interface PermissionQuery {
+    userId: string;
+    resource: {
+        id: string;
+        type: PermissionResourceType;
+        source: PermissionSource;
+        organizationId: string;
+        context?: Context | SetDocumentsContext;
+    };
+}
+export interface PermissionResult {
+    userId: string;
+    resourceId: string;
+    organizationId: string;
+    type: PermissionResourceType;
+    accessRole?: UserPermissionAccessRole;
+    expiresAt?: number;
+    hasAccess: boolean;
 }