@100mslive/hms-whiteboard 0.0.0-alpha.0

package/dist/ErrorFallback.d.ts

@@ -0,0 +1,7 @@
+import { ComponentType } from 'react';
+import { Editor } from '@tldraw/tldraw';
+export type TLErrorFallbackComponent = ComponentType<{
+    error: unknown;
+    editor?: Editor;
+}>;
+export declare const ErrorFallback: TLErrorFallbackComponent;

package/dist/Whiteboard.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import '@tldraw/tldraw/tldraw.css';
+import './index.css';
+export interface WhiteboardProps {
+    endpoint?: string;
+    token?: string;
+    zoomToContent?: boolean;
+    transparentCanvas?: boolean;
+    onMount?: (args: {
+        store?: unknown;
+        editor?: unknown;
+    }) => void;
+}
+export declare function Whiteboard({ onMount, endpoint, token, zoomToContent, transparentCanvas }: WhiteboardProps): React.JSX.Element;

package/dist/grpc/sessionstore.client.d.ts

@@ -0,0 +1,102 @@
+import type { RpcOptions, RpcTransport, ServerStreamingCall, ServiceInfo, UnaryCall } from '@protobuf-ts/runtime-rpc';
+import type { ChangeStream, DeleteRequest, DeleteResponse, Event, GetRequest, GetResponse, HelloRequest, HelloResponse, OpenRequest, SetRequest, SetResponse, SubscribeRequest } from './sessionstore';
+/**
+ * @generated from protobuf service sessionstorepb.Api
+ */
+export interface IApiClient {
+    /**
+     * @generated from protobuf rpc: Hello(sessionstorepb.HelloRequest) returns (sessionstorepb.HelloResponse);
+     */
+    hello(input: HelloRequest, options?: RpcOptions): UnaryCall<HelloRequest, HelloResponse>;
+    /**
+     * @generated from protobuf rpc: Subscribe(sessionstorepb.SubscribeRequest) returns (stream sessionstorepb.Event);
+     */
+    subscribe(input: SubscribeRequest, options?: RpcOptions): ServerStreamingCall<SubscribeRequest, Event>;
+}
+/**
+ * @generated from protobuf service sessionstorepb.Api
+ */
+export declare class ApiClient implements IApiClient, ServiceInfo {
+    private readonly _transport;
+    typeName: string;
+    methods: import("@protobuf-ts/runtime-rpc").MethodInfo<any, any>[];
+    options: {
+        [extensionName: string]: import("@protobuf-ts/runtime").JsonValue;
+    };
+    constructor(_transport: RpcTransport);
+    /**
+     * @generated from protobuf rpc: Hello(sessionstorepb.HelloRequest) returns (sessionstorepb.HelloResponse);
+     */
+    hello(input: HelloRequest, options?: RpcOptions): UnaryCall<HelloRequest, HelloResponse>;
+    /**
+     * @generated from protobuf rpc: Subscribe(sessionstorepb.SubscribeRequest) returns (stream sessionstorepb.Event);
+     */
+    subscribe(input: SubscribeRequest, options?: RpcOptions): ServerStreamingCall<SubscribeRequest, Event>;
+}
+/**
+ * @generated from protobuf service sessionstorepb.Store
+ */
+export interface IStoreClient {
+    /**
+     * open - start listening to updates in keys with provided match patterns
+     * provide change_id as last received ID to resume updates
+     *
+     * @generated from protobuf rpc: open(sessionstorepb.OpenRequest) returns (stream sessionstorepb.ChangeStream);
+     */
+    open(input: OpenRequest, options?: RpcOptions): ServerStreamingCall<OpenRequest, ChangeStream>;
+    /**
+     * get last stored value in given key
+     *
+     * @generated from protobuf rpc: get(sessionstorepb.GetRequest) returns (sessionstorepb.GetResponse);
+     */
+    get(input: GetRequest, options?: RpcOptions): UnaryCall<GetRequest, GetResponse>;
+    /**
+     * set key value
+     *
+     * @generated from protobuf rpc: set(sessionstorepb.SetRequest) returns (sessionstorepb.SetResponse);
+     */
+    set(input: SetRequest, options?: RpcOptions): UnaryCall<SetRequest, SetResponse>;
+    /**
+     * delete key from store
+     *
+     * @generated from protobuf rpc: delete(sessionstorepb.DeleteRequest) returns (sessionstorepb.DeleteResponse);
+     */
+    delete(input: DeleteRequest, options?: RpcOptions): UnaryCall<DeleteRequest, DeleteResponse>;
+}
+/**
+ * @generated from protobuf service sessionstorepb.Store
+ */
+export declare class StoreClient implements IStoreClient, ServiceInfo {
+    private readonly _transport;
+    typeName: string;
+    methods: import("@protobuf-ts/runtime-rpc").MethodInfo<any, any>[];
+    options: {
+        [extensionName: string]: import("@protobuf-ts/runtime").JsonValue;
+    };
+    constructor(_transport: RpcTransport);
+    /**
+     * open - start listening to updates in keys with provided match patterns
+     * provide change_id as last received ID to resume updates
+     *
+     * @generated from protobuf rpc: open(sessionstorepb.OpenRequest) returns (stream sessionstorepb.ChangeStream);
+     */
+    open(input: OpenRequest, options?: RpcOptions): ServerStreamingCall<OpenRequest, ChangeStream>;
+    /**
+     * get last stored value in given key
+     *
+     * @generated from protobuf rpc: get(sessionstorepb.GetRequest) returns (sessionstorepb.GetResponse);
+     */
+    get(input: GetRequest, options?: RpcOptions): UnaryCall<GetRequest, GetResponse>;
+    /**
+     * set key value
+     *
+     * @generated from protobuf rpc: set(sessionstorepb.SetRequest) returns (sessionstorepb.SetResponse);
+     */
+    set(input: SetRequest, options?: RpcOptions): UnaryCall<SetRequest, SetResponse>;
+    /**
+     * delete key from store
+     *
+     * @generated from protobuf rpc: delete(sessionstorepb.DeleteRequest) returns (sessionstorepb.DeleteResponse);
+     */
+    delete(input: DeleteRequest, options?: RpcOptions): UnaryCall<DeleteRequest, DeleteResponse>;
+}

package/dist/grpc/sessionstore.d.ts

@@ -0,0 +1,400 @@
+import { ServiceType } from '@protobuf-ts/runtime-rpc';
+import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from '@protobuf-ts/runtime';
+import type { PartialMessage } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+/**
+ * @generated from protobuf message sessionstorepb.HelloRequest
+ */
+export interface HelloRequest {
+    /**
+     * @generated from protobuf field: string name = 1;
+     */
+    name: string;
+}
+/**
+ * @generated from protobuf message sessionstorepb.HelloResponse
+ */
+export interface HelloResponse {
+    /**
+     * @generated from protobuf field: string response = 1;
+     */
+    response: string;
+}
+/**
+ * @generated from protobuf message sessionstorepb.SubscribeRequest
+ */
+export interface SubscribeRequest {
+    /**
+     * @generated from protobuf field: string name = 1;
+     */
+    name: string;
+    /**
+     * @generated from protobuf field: int64 offset = 2;
+     */
+    offset: bigint;
+}
+/**
+ * @generated from protobuf message sessionstorepb.Event
+ */
+export interface Event {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: int64 sequence = 2;
+     */
+    sequence: bigint;
+}
+/**
+ * define new structure for value based on client needs and add support in
+ * following message
+ *
+ * @generated from protobuf message sessionstorepb.Value
+ */
+export interface Value {
+    /**
+     * @generated from protobuf field: sessionstorepb.Value.Type type = 1;
+     */
+    type: Value_Type;
+    /**
+     * @generated from protobuf oneof: Data
+     */
+    data: {
+        oneofKind: 'number';
+        /**
+         * @generated from protobuf field: int64 number = 2;
+         */
+        number: bigint;
+    } | {
+        oneofKind: 'float';
+        /**
+         * @generated from protobuf field: float float = 3;
+         */
+        float: number;
+    } | {
+        oneofKind: 'str';
+        /**
+         * @generated from protobuf field: string str = 4;
+         */
+        str: string;
+    } | {
+        oneofKind: 'rawBytes';
+        /**
+         * @generated from protobuf field: bytes raw_bytes = 5;
+         */
+        rawBytes: Uint8Array;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf enum sessionstorepb.Value.Type
+ */
+export declare enum Value_Type {
+    /**
+     * @generated from protobuf enum value: NONE = 0;
+     */
+    NONE = 0,
+    /**
+     * @generated from protobuf enum value: BYTES = 1;
+     */
+    BYTES = 1,
+    /**
+     * @generated from protobuf enum value: STRING = 2;
+     */
+    STRING = 2,
+    /**
+     * @generated from protobuf enum value: INTEGER = 3;
+     */
+    INTEGER = 3,
+    /**
+     * @generated from protobuf enum value: FLOAT = 4;
+     */
+    FLOAT = 4
+}
+/**
+ * @generated from protobuf message sessionstorepb.GetRequest
+ */
+export interface GetRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+}
+/**
+ * @generated from protobuf message sessionstorepb.GetResponse
+ */
+export interface GetResponse {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: string namespace = 2;
+     */
+    namespace: string;
+    /**
+     * @generated from protobuf field: sessionstorepb.Value value = 3;
+     */
+    value?: Value;
+}
+/**
+ * @generated from protobuf message sessionstorepb.DeleteRequest
+ */
+export interface DeleteRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+}
+/**
+ * @generated from protobuf message sessionstorepb.DeleteResponse
+ */
+export interface DeleteResponse {
+}
+/**
+ * @generated from protobuf message sessionstorepb.SetRequest
+ */
+export interface SetRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: sessionstorepb.Value value = 3;
+     */
+    value?: Value;
+}
+/**
+ * @generated from protobuf message sessionstorepb.SetResponse
+ */
+export interface SetResponse {
+}
+/**
+ * @generated from protobuf message sessionstorepb.ChangeStream
+ */
+export interface ChangeStream {
+    /**
+     * @generated from protobuf field: string change_id = 1;
+     */
+    changeId: string;
+    /**
+     * @generated from protobuf field: string key = 2;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: string namespace = 3;
+     */
+    namespace: string;
+    /**
+     * @generated from protobuf field: sessionstorepb.Value value = 4;
+     */
+    value?: Value;
+    /**
+     * @generated from protobuf field: string from_id = 5;
+     */
+    fromId: string;
+}
+/**
+ * @generated from protobuf message sessionstorepb.Select
+ */
+export interface Select {
+    /**
+     * @generated from protobuf oneof: match
+     */
+    match: {
+        oneofKind: 'all';
+        /**
+         * @generated from protobuf field: string all = 1;
+         */
+        all: string;
+    } | {
+        oneofKind: 'key';
+        /**
+         * @generated from protobuf field: string key = 2;
+         */
+        key: string;
+    } | {
+        oneofKind: 'prefix';
+        /**
+         * @generated from protobuf field: string prefix = 3;
+         */
+        prefix: string;
+    } | {
+        oneofKind: 'suffix';
+        /**
+         * @generated from protobuf field: string suffix = 4;
+         */
+        suffix: string;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message sessionstorepb.OpenRequest
+ */
+export interface OpenRequest {
+    /**
+     * last received change_id for reconnection, "" if first connection
+     *
+     * @generated from protobuf field: string change_id = 1;
+     */
+    changeId: string;
+    /**
+     * @generated from protobuf field: repeated sessionstorepb.Select select = 3;
+     */
+    select: Select[];
+}
+declare class HelloRequest$Type extends MessageType<HelloRequest> {
+    constructor();
+    create(value?: PartialMessage<HelloRequest>): HelloRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HelloRequest): HelloRequest;
+    internalBinaryWrite(message: HelloRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.HelloRequest
+ */
+export declare const HelloRequest: HelloRequest$Type;
+declare class HelloResponse$Type extends MessageType<HelloResponse> {
+    constructor();
+    create(value?: PartialMessage<HelloResponse>): HelloResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HelloResponse): HelloResponse;
+    internalBinaryWrite(message: HelloResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.HelloResponse
+ */
+export declare const HelloResponse: HelloResponse$Type;
+declare class SubscribeRequest$Type extends MessageType<SubscribeRequest> {
+    constructor();
+    create(value?: PartialMessage<SubscribeRequest>): SubscribeRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SubscribeRequest): SubscribeRequest;
+    internalBinaryWrite(message: SubscribeRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.SubscribeRequest
+ */
+export declare const SubscribeRequest: SubscribeRequest$Type;
+declare class Event$Type extends MessageType<Event> {
+    constructor();
+    create(value?: PartialMessage<Event>): Event;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event): Event;
+    internalBinaryWrite(message: Event, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.Event
+ */
+export declare const Event: Event$Type;
+declare class Value$Type extends MessageType<Value> {
+    constructor();
+    create(value?: PartialMessage<Value>): Value;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Value): Value;
+    internalBinaryWrite(message: Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.Value
+ */
+export declare const Value: Value$Type;
+declare class GetRequest$Type extends MessageType<GetRequest> {
+    constructor();
+    create(value?: PartialMessage<GetRequest>): GetRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetRequest): GetRequest;
+    internalBinaryWrite(message: GetRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.GetRequest
+ */
+export declare const GetRequest: GetRequest$Type;
+declare class GetResponse$Type extends MessageType<GetResponse> {
+    constructor();
+    create(value?: PartialMessage<GetResponse>): GetResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetResponse): GetResponse;
+    internalBinaryWrite(message: GetResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.GetResponse
+ */
+export declare const GetResponse: GetResponse$Type;
+declare class DeleteRequest$Type extends MessageType<DeleteRequest> {
+    constructor();
+    create(value?: PartialMessage<DeleteRequest>): DeleteRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteRequest): DeleteRequest;
+    internalBinaryWrite(message: DeleteRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.DeleteRequest
+ */
+export declare const DeleteRequest: DeleteRequest$Type;
+declare class DeleteResponse$Type extends MessageType<DeleteResponse> {
+    constructor();
+    create(value?: PartialMessage<DeleteResponse>): DeleteResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteResponse): DeleteResponse;
+    internalBinaryWrite(message: DeleteResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.DeleteResponse
+ */
+export declare const DeleteResponse: DeleteResponse$Type;
+declare class SetRequest$Type extends MessageType<SetRequest> {
+    constructor();
+    create(value?: PartialMessage<SetRequest>): SetRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SetRequest): SetRequest;
+    internalBinaryWrite(message: SetRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.SetRequest
+ */
+export declare const SetRequest: SetRequest$Type;
+declare class SetResponse$Type extends MessageType<SetResponse> {
+    constructor();
+    create(value?: PartialMessage<SetResponse>): SetResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SetResponse): SetResponse;
+    internalBinaryWrite(message: SetResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.SetResponse
+ */
+export declare const SetResponse: SetResponse$Type;
+declare class ChangeStream$Type extends MessageType<ChangeStream> {
+    constructor();
+    create(value?: PartialMessage<ChangeStream>): ChangeStream;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ChangeStream): ChangeStream;
+    internalBinaryWrite(message: ChangeStream, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.ChangeStream
+ */
+export declare const ChangeStream: ChangeStream$Type;
+declare class Select$Type extends MessageType<Select> {
+    constructor();
+    create(value?: PartialMessage<Select>): Select;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Select): Select;
+    internalBinaryWrite(message: Select, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.Select
+ */
+export declare const Select: Select$Type;
+declare class OpenRequest$Type extends MessageType<OpenRequest> {
+    constructor();
+    create(value?: PartialMessage<OpenRequest>): OpenRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OpenRequest): OpenRequest;
+    internalBinaryWrite(message: OpenRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message sessionstorepb.OpenRequest
+ */
+export declare const OpenRequest: OpenRequest$Type;
+/**
+ * @generated ServiceType for protobuf service sessionstorepb.Api
+ */
+export declare const Api: ServiceType;
+/**
+ * @generated ServiceType for protobuf service sessionstorepb.Store
+ */
+export declare const Store: ServiceType;
+export {};

package/dist/hooks/StoreClient.d.ts

@@ -0,0 +1,13 @@
+interface OpenCallbacks<T> {
+    handleChange: (key: string, value?: T) => void;
+    handleError: (error: Error) => void;
+}
+export declare class SessionStore<T> {
+    private storeClient;
+    constructor(endpoint: string, token: string);
+    open({ handleChange, handleError }: OpenCallbacks<T>): void;
+    set(key: string, value?: T): import("@protobuf-ts/runtime-rpc").UnaryCall<import("../grpc/sessionstore").SetRequest, import("../grpc/sessionstore").SetResponse>;
+    get(key: string): Promise<T | undefined>;
+    delete(key: string): import("@protobuf-ts/runtime-rpc").UnaryCall<import("../grpc/sessionstore").DeleteRequest, import("../grpc/sessionstore").DeleteResponse>;
+}
+export {};

package/dist/hooks/default_store.d.ts

@@ -0,0 +1,141 @@
+export declare const DEFAULT_STORE: {
+    store: {
+        'document:document': {
+            gridSize: number;
+            name: string;
+            meta: {};
+            id: string;
+            typeName: string;
+        };
+        'pointer:pointer': {
+            id: string;
+            typeName: string;
+            x: number;
+            y: number;
+            lastActivityTimestamp: number;
+            meta: {};
+        };
+        'page:page': {
+            meta: {};
+            id: string;
+            name: string;
+            index: string;
+            typeName: string;
+        };
+        'camera:page:page': {
+            x: number;
+            y: number;
+            z: number;
+            meta: {};
+            id: string;
+            typeName: string;
+        };
+        'instance_page_state:page:page': {
+            editingShapeId: null;
+            croppingShapeId: null;
+            selectedShapeIds: never[];
+            hoveredShapeId: null;
+            erasingShapeIds: never[];
+            hintingShapeIds: never[];
+            focusedGroupId: null;
+            meta: {};
+            id: string;
+            pageId: string;
+            typeName: string;
+        };
+        'instance:instance': {
+            followingUserId: null;
+            opacityForNextShape: number;
+            stylesForNextShape: {};
+            brush: null;
+            scribble: null;
+            cursor: {
+                type: string;
+                rotation: number;
+            };
+            isFocusMode: boolean;
+            exportBackground: boolean;
+            isDebugMode: boolean;
+            isToolLocked: boolean;
+            screenBounds: {
+                x: number;
+                y: number;
+                w: number;
+                h: number;
+            };
+            zoomBrush: null;
+            isGridMode: boolean;
+            isPenMode: boolean;
+            chatMessage: string;
+            isChatting: boolean;
+            highlightedUserIds: never[];
+            canMoveCamera: boolean;
+            isFocused: boolean;
+            devicePixelRatio: number;
+            isCoarsePointer: boolean;
+            isHoveringCanvas: boolean;
+            openMenus: never[];
+            isChangingStyle: boolean;
+            isReadonly: boolean;
+            meta: {};
+            id: string;
+            currentPageId: string;
+            typeName: string;
+        };
+    };
+    schema: {
+        schemaVersion: number;
+        storeVersion: number;
+        recordVersions: {
+            asset: {
+                version: number;
+                subTypeKey: string;
+                subTypeVersions: {
+                    image: number;
+                    video: number;
+                    bookmark: number;
+                };
+            };
+            camera: {
+                version: number;
+            };
+            document: {
+                version: number;
+            };
+            instance: {
+                version: number;
+            };
+            instance_page_state: {
+                version: number;
+            };
+            page: {
+                version: number;
+            };
+            shape: {
+                version: number;
+                subTypeKey: string;
+                subTypeVersions: {
+                    group: number;
+                    text: number;
+                    bookmark: number;
+                    draw: number;
+                    geo: number;
+                    note: number;
+                    line: number;
+                    frame: number;
+                    arrow: number;
+                    highlight: number;
+                    embed: number;
+                    image: number;
+                    video: number;
+                };
+            };
+            instance_presence: {
+                version: number;
+            };
+            pointer: {
+                version: number;
+            };
+        };
+    };
+};

package/dist/hooks/useCollaboration.d.ts

@@ -0,0 +1,8 @@
+import { Editor, TLAnyShapeUtilConstructor, TLStoreWithStatus } from '@tldraw/tldraw';
+export declare function useCollaboration({ endpoint, token, editor, shapeUtils, zoomToContent, }: {
+    endpoint?: string;
+    token?: string;
+    editor?: Editor;
+    shapeUtils?: TLAnyShapeUtilConstructor[];
+    zoomToContent?: boolean;
+}): TLStoreWithStatus;

package/dist/hooks/useSessionStore.d.ts

@@ -0,0 +1,7 @@
+import { TLRecord } from '@tldraw/tldraw';
+import { SessionStore } from './StoreClient';
+export declare const useSessionStore: ({ token, endpoint, handleError, }: {
+    token?: string;
+    endpoint?: string;
+    handleError: (error: Error) => void;
+}) => void | SessionStore<TLRecord>;