@werxt/livekit-components-react 2.9.20

package/dist/hooks/useFacingMode.d.ts

@@ -0,0 +1,10 @@
+import { TrackReferenceOrPlaceholder } from '@livekit/components-core';
+/**
+ * Try to determine the `facingMode` of a local participant video track.
+ * @remarks
+ * Works only on local video tracks.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
+ * @alpha
+ */
+export declare function useFacingMode(trackReference: TrackReferenceOrPlaceholder): 'user' | 'environment' | 'left' | 'right' | 'undefined';
+//# sourceMappingURL=useFacingMode.d.ts.map

package/dist/hooks/useFacingMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFacingMode.d.ts","sourceRoot":"","sources":["../../src/hooks/useFacingMode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAG5E;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,cAAc,EAAE,2BAA2B,GAC1C,MAAM,GAAG,aAAa,GAAG,MAAM,GAAG,OAAO,GAAG,WAAW,CASzD"}

package/dist/hooks/useFocusToggle.d.ts

@@ -0,0 +1,26 @@
+import { TrackReferenceOrPlaceholder } from '@livekit/components-core';
+import * as React from 'react';
+/** @public */
+export interface UseFocusToggleProps {
+    trackRef?: TrackReferenceOrPlaceholder;
+    props: React.ButtonHTMLAttributes<HTMLButtonElement>;
+}
+/**
+ * The `useFocusToggle` hook is used to implement the `FocusToggle` or your custom implementation of it.
+ * The `TrackReferenceOrPlaceholder` is used to register a onClick handler and to identify the track to focus on.
+ *
+ * @example
+ * ```tsx
+ * const { mergedProps, inFocus } = useFocusToggle({ trackRef, props: yourButtonProps });
+ * return <button {...mergedProps}>{inFocus ? 'Unfocus' : 'Focus'}</button>;
+ * ```
+ * @public
+ */
+export declare function useFocusToggle({ trackRef, props }: UseFocusToggleProps): {
+    mergedProps: React.ButtonHTMLAttributes<HTMLButtonElement> & {
+        className: string;
+        onClick: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    };
+    inFocus: boolean;
+};
+//# sourceMappingURL=useFocusToggle.d.ts.map

package/dist/hooks/useFocusToggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusToggle.d.ts","sourceRoot":"","sources":["../../src/hooks/useFocusToggle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAI5E,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,cAAc;AACd,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,2BAA2B,CAAC;IACvC,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,CAAC;CACtD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,mBAAmB;;;yBAc9C,KAAK,CAAC,UAAU,CAAC,iBAAiB,EAAE,UAAU,CAAC;;;EAqBvE"}

package/dist/hooks/useGridLayout.d.ts

@@ -0,0 +1,27 @@
+import { GridLayoutDefinition, GridLayoutInfo } from '@livekit/components-core';
+import * as React from 'react';
+/**
+ * The `useGridLayout` hook tries to select the best layout to fit all tiles.
+ * If the available screen space is not enough, it will reduce the number of maximum visible
+ * tiles and select a layout that still works visually within the given limitations.
+ * As the order of tiles changes over time, the hook tries to keep visual updates to a minimum
+ * while trying to display important tiles such as speaking participants or screen shares.
+ *
+ * @example
+ * ```tsx
+ * const { layout } = useGridLayout(gridElement, trackCount);
+ * ```
+ * @public
+ */
+export declare function useGridLayout(
+/** HTML element that contains the grid. */
+gridElement: React.RefObject<HTMLDivElement>, 
+/** Count of tracks that should get layed out */
+trackCount: number, options?: {
+    gridLayouts?: GridLayoutDefinition[];
+}): {
+    layout: GridLayoutInfo;
+    containerWidth: number;
+    containerHeight: number;
+};
+//# sourceMappingURL=useGridLayout.d.ts.map

package/dist/hooks/useGridLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGridLayout.d.ts","sourceRoot":"","sources":["../../src/hooks/useGridLayout.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AACrF,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa;AAC3B,2CAA2C;AAC3C,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC;AAC5C,gDAAgD;AAChD,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE;IACP,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACjC,GACL;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,CAiB7E"}

package/dist/hooks/useIsEncrypted.d.ts

@@ -0,0 +1,12 @@
+import { Participant, Room } from 'livekit-client';
+/**
+ * @alpha
+ */
+export interface UseIsEncryptedOptions {
+    room?: Room;
+}
+/**
+ * @alpha
+ */
+export declare function useIsEncrypted(participant?: Participant, options?: UseIsEncryptedOptions): boolean;
+//# sourceMappingURL=useIsEncrypted.d.ts.map

package/dist/hooks/useIsEncrypted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsEncrypted.d.ts","sourceRoot":"","sources":["../../src/hooks/useIsEncrypted.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAKxD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,WAAW,CAAC,EAAE,WAAW,EAAE,OAAO,GAAE,qBAA0B,WAW5F"}

package/dist/hooks/useIsMuted.d.ts

@@ -0,0 +1,22 @@
+import { TrackReferenceOrPlaceholder } from '@livekit/components-core';
+import { Participant } from 'livekit-client';
+/** @public */
+export interface UseIsMutedOptions {
+    participant?: Participant;
+}
+/**
+ * The `useIsMuted` hook is used to implement the `TrackMutedIndicator` or your custom implementation of it.
+ * It returns a `boolean` that indicates if the track is muted or not.
+ *
+ * @example With a track reference
+ * ```tsx
+ * const isMuted = useIsMuted(track);
+ * ```
+ *
+ * @param trackRef - A `TrackReference` indicating the track to monitor.
+ * @returns boolean indicating if the track is muted
+ *
+ * @public
+ */
+export declare function useIsMuted(trackRef: TrackReferenceOrPlaceholder): boolean;
+//# sourceMappingURL=useIsMuted.d.ts.map

package/dist/hooks/useIsMuted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsMuted.d.ts","sourceRoot":"","sources":["../../src/hooks/useIsMuted.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,2BAA2B,EAGjC,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,WAAW,EAAS,MAAM,gBAAgB,CAAC;AAIzD,cAAc;AACd,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,2BAA2B,GAAG,OAAO,CAAC"}

package/dist/hooks/useIsRecording.d.ts

@@ -0,0 +1,11 @@
+import { Room } from 'livekit-client';
+/**
+ * The `useIsRecording` hook returns a `boolean` that indicates if the room is currently being recorded.
+ * @example
+ * ```tsx
+ * const isRecording = useIsRecording();
+ * ```
+ * @public
+ */
+export declare function useIsRecording(room?: Room): boolean;
+//# sourceMappingURL=useIsRecording.d.ts.map

package/dist/hooks/useIsRecording.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsRecording.d.ts","sourceRoot":"","sources":["../../src/hooks/useIsRecording.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,CAAC,EAAE,IAAI,WAOzC"}

package/dist/hooks/useIsSpeaking.d.ts

@@ -0,0 +1,11 @@
+import { Participant } from 'livekit-client';
+/**
+ * The `useIsSpeaking` hook returns a `boolean` that indicates if the participant is speaking or not.
+ * @example
+ * ```tsx
+ * const isSpeaking = useIsSpeaking(participant);
+ * ```
+ * @public
+ */
+export declare function useIsSpeaking(participant?: Participant): boolean;
+//# sourceMappingURL=useIsSpeaking.d.ts.map

package/dist/hooks/useIsSpeaking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsSpeaking.d.ts","sourceRoot":"","sources":["../../src/hooks/useIsSpeaking.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAKlD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,WAAW,CAAC,EAAE,WAAW,WAMtD"}

package/dist/hooks/useLiveKitRoom.d.ts

@@ -0,0 +1,19 @@
+import { Room } from 'livekit-client';
+import { HTMLAttributes } from 'react';
+import { LiveKitRoomProps } from '../components';
+/**
+ * The `useLiveKitRoom` hook is used to implement the `LiveKitRoom` or your custom implementation of it.
+ * It returns a `Room` instance and HTML props that should be applied to the root element of the component.
+ *
+ * @example
+ * ```tsx
+ * const { room, htmlProps } = useLiveKitRoom();
+ * return <div {...htmlProps}>...</div>;
+ * ```
+ * @public
+ */
+export declare function useLiveKitRoom<T extends HTMLElement>(props: LiveKitRoomProps): {
+    room: Room | undefined;
+    htmlProps: HTMLAttributes<T>;
+};
+//# sourceMappingURL=useLiveKitRoom.d.ts.map

package/dist/hooks/useLiveKitRoom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLiveKitRoom.d.ts","sourceRoot":"","sources":["../../src/hooks/useLiveKitRoom.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAiC,MAAM,gBAAgB,CAAC;AAErE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAE5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAUtD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,WAAW,EAClD,KAAK,EAAE,gBAAgB,GACtB;IACD,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC;IACvB,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;CAC9B,CAyJA"}

package/dist/hooks/useLocalParticipant.d.ts

@@ -0,0 +1,29 @@
+import { TrackPublication, LocalParticipant, Room } from 'livekit-client';
+/** @public */
+export interface UseLocalParticipantOptions {
+    /**
+     * The room to use. If not provided, the hook will use the room from the context.
+     */
+    room?: Room;
+}
+/**
+ * The `useLocalParticipant` hook returns the local participant and the associated state
+ * around the participant.
+ *
+ * @example
+ * ```tsx
+ * const { localParticipant } = useLocalParticipant();
+ * ```
+ * @public
+ */
+export declare function useLocalParticipant(options?: UseLocalParticipantOptions): {
+    isMicrophoneEnabled: boolean;
+    isScreenShareEnabled: boolean;
+    isCameraEnabled: boolean;
+    microphoneTrack: TrackPublication | undefined;
+    cameraTrack: TrackPublication | undefined;
+    lastMicrophoneError: Error | undefined;
+    lastCameraError: Error | undefined;
+    localParticipant: LocalParticipant;
+};
+//# sourceMappingURL=useLocalParticipant.d.ts.map

package/dist/hooks/useLocalParticipant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocalParticipant.d.ts","sourceRoot":"","sources":["../../src/hooks/useLocalParticipant.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAI/E,cAAc;AACd,MAAM,WAAW,0BAA0B;IACzC;;OAEG;IACH,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,0BAA+B;;;;;;;;;EAgD3E"}

package/dist/hooks/useLocalParticipantPermissions.d.ts

@@ -0,0 +1,12 @@
+import { ParticipantPermission } from '@livekit/protocol';
+/**
+ * The `useLocalParticipantPermissions` hook returns the local participant's permissions.
+ *
+ * @example
+ * ```tsx
+ * const { canPublish, canPublishData } = useLocalParticipantPermissions();
+ * ```
+ * @public
+ */
+export declare function useLocalParticipantPermissions(): ParticipantPermission | undefined;
+//# sourceMappingURL=useLocalParticipantPermissions.d.ts.map

package/dist/hooks/useLocalParticipantPermissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocalParticipantPermissions.d.ts","sourceRoot":"","sources":["../../src/hooks/useLocalParticipantPermissions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAK/D;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,IAAI,qBAAqB,GAAG,SAAS,CAQlF"}

package/dist/hooks/useMediaDeviceSelect.d.ts

@@ -0,0 +1,41 @@
+import { Room, LocalAudioTrack, LocalVideoTrack } from 'livekit-client';
+/** @public */
+export interface UseMediaDeviceSelectProps {
+    kind: MediaDeviceKind;
+    room?: Room;
+    track?: LocalAudioTrack | LocalVideoTrack;
+    /**
+     * this will call getUserMedia if the permissions are not yet given to enumerate the devices with device labels.
+     * in some browsers multiple calls to getUserMedia result in multiple permission prompts.
+     * It's generally advised only flip this to true, once a (preview) track has been acquired successfully with the
+     * appropriate permissions.
+     *
+     * @see {@link MediaDeviceMenu}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/enumerateDevices | MDN enumerateDevices}
+     */
+    requestPermissions?: boolean;
+    /**
+     * this callback gets called if an error is thrown when failing to select a device and also if a user
+     * denied permissions, eventhough the `requestPermissions` option is set to `true`.
+     * Most commonly this will emit a MediaDeviceError
+     */
+    onError?: (e: Error) => void;
+}
+/**
+ * The `useMediaDeviceSelect` hook is used to implement the `MediaDeviceSelect` component and
+ * returns o.a. the list of devices of a given kind (audioinput or videoinput), the currently active device
+ * and a function to set the the active device.
+ *
+ * @example
+ * ```tsx
+ * const { devices, activeDeviceId, setActiveMediaDevice } = useMediaDeviceSelect({kind: 'audioinput'});
+ * ```
+ * @public
+ */
+export declare function useMediaDeviceSelect({ kind, room, track, requestPermissions, onError, }: UseMediaDeviceSelectProps): {
+    devices: MediaDeviceInfo[];
+    className: string;
+    activeDeviceId: string;
+    setActiveMediaDevice: (id: string, options?: import('@livekit/components-core').SetMediaDeviceOptions) => Promise<void>;
+};
+//# sourceMappingURL=useMediaDeviceSelect.d.ts.map

package/dist/hooks/useMediaDeviceSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMediaDeviceSelect.d.ts","sourceRoot":"","sources":["../../src/hooks/useMediaDeviceSelect.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKlF,cAAc;AACd,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,KAAK,CAAC,EAAE,eAAe,GAAG,eAAe,CAAC;IAC1C;;;;;;;;OAQG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;CAC9B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,kBAAkB,EAClB,OAAO,GACR,EAAE,yBAAyB;;;;;EAkC3B"}

package/dist/hooks/useMediaDevices.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The `useMediaDevices` hook returns the list of media devices of a given kind.
+ *
+ * @example
+ * ```tsx
+ * const videoDevices = useMediaDevices({ kind: 'videoinput' });
+ * const audioDevices = useMediaDevices({ kind: 'audioinput' });
+ * ```
+ * @public
+ */
+export declare function useMediaDevices({ kind, onError, }: {
+    kind: MediaDeviceKind;
+    onError?: (e: Error) => void;
+}): MediaDeviceInfo[];
+//# sourceMappingURL=useMediaDevices.d.ts.map

package/dist/hooks/useMediaDevices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMediaDevices.d.ts","sourceRoot":"","sources":["../../src/hooks/useMediaDevices.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,EAC9B,IAAI,EACJ,OAAO,GACR,EAAE;IACD,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;CAC9B,qBAOA"}

package/dist/hooks/useMediaTrackBySourceOrName.d.ts

@@ -0,0 +1,18 @@
+import { TrackIdentifier } from '@livekit/components-core';
+import * as React from 'react';
+/** @public */
+export interface UseMediaTrackOptions {
+    element?: React.RefObject<HTMLMediaElement> | null;
+    props?: React.HTMLAttributes<HTMLVideoElement | HTMLAudioElement>;
+}
+/**
+ * @internal
+ */
+export declare function useMediaTrackBySourceOrName(observerOptions: TrackIdentifier, options?: UseMediaTrackOptions): {
+    publication: import('livekit-client').TrackPublication | undefined;
+    isMuted: boolean | undefined;
+    isSubscribed: boolean | undefined;
+    track: import('livekit-client').Track<import("livekit-client").Track.Kind> | undefined;
+    elementProps: React.HTMLAttributes<HTMLElement>;
+};
+//# sourceMappingURL=useMediaTrackBySourceOrName.d.ts.map

package/dist/hooks/useMediaTrackBySourceOrName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMediaTrackBySourceOrName.d.ts","sourceRoot":"","sources":["../../src/hooks/useMediaTrackBySourceOrName.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAOhE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,cAAc;AACd,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC;IACnD,KAAK,CAAC,EAAE,KAAK,CAAC,cAAc,CAAC,gBAAgB,GAAG,gBAAgB,CAAC,CAAC;CACnE;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,eAAe,EAAE,eAAe,EAChC,OAAO,GAAE,oBAAyB;;;;;;EA2EnC"}

package/dist/hooks/usePagination.d.ts

@@ -0,0 +1,24 @@
+import { TrackReferenceOrPlaceholder } from '@livekit/components-core';
+/**
+ * The `usePagination` hook implements simple pagination logic for use with arrays.
+ * @example
+ * ```tsx
+ * const tracks = useTracks();
+ * const pagination = usePagination(4, tracks);
+ *
+ * <TrackLoop tracks={pagination.tracks} />
+ * ```
+ * @alpha
+ */
+export declare function usePagination(itemPerPage: number, trackReferences: TrackReferenceOrPlaceholder[]): {
+    totalPageCount: number;
+    nextPage: () => void;
+    prevPage: () => void;
+    setPage: (num: number) => void;
+    firstItemIndex: number;
+    lastItemIndex: number;
+    tracks: TrackReferenceOrPlaceholder[];
+    currentPage: number;
+};
+export default usePagination;
+//# sourceMappingURL=usePagination.d.ts.map

package/dist/hooks/usePagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePagination.d.ts","sourceRoot":"","sources":["../../src/hooks/usePagination.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAI5E;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,eAAe,EAAE,2BAA2B,EAAE;;;;mBAyBxE,MAAM;;;;;EAwB9B;AAED,eAAe,aAAa,CAAC"}

package/dist/hooks/useParticipantAttributes.d.ts

@@ -0,0 +1,30 @@
+import { Participant } from 'livekit-client';
+/**
+ * The `useParticipantAttributes` hook returns the attributes of a given participant and allows to set them.
+ * It requires a `Participant` object passed as property or via the `ParticipantContext`.
+ *
+ * @example
+ * ```tsx
+ * const { attributes } = useParticipantAttributes({ participant });
+ * ```
+ * @public
+ */
+export interface UseParticipantAttributesOptions {
+    participant?: Participant;
+}
+/** @public */
+export declare function useParticipantAttributes(props?: UseParticipantAttributesOptions): {
+    attributes: Readonly<Record<string, string>> | undefined;
+};
+/**
+ * The `useParticipantAttribute` hook returns the latest value of a given attribute key of a participant.
+ * It requires a `Participant` object passed as property in the `UseParticipantAttributesOptions` or via the `ParticipantContext`.
+ *
+ * @example
+ * ```tsx
+ * const myAttributeValue = useParticipantAttribute('targetAttributeName');
+ * ```
+ * @public
+ */
+export declare function useParticipantAttribute(attributeKey: string, options?: UseParticipantAttributesOptions): string;
+//# sourceMappingURL=useParticipantAttributes.d.ts.map

package/dist/hooks/useParticipantAttributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useParticipantAttributes.d.ts","sourceRoot":"","sources":["../../src/hooks/useParticipantAttributes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAKlD;;;;;;;;;GASG;AACH,MAAM,WAAW,+BAA+B;IAC9C,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,cAAc;AACd,wBAAgB,wBAAwB,CAAC,KAAK,GAAE,+BAAoC;;EAanF;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,+BAAoC,UAoB9C"}

package/dist/hooks/useParticipantInfo.d.ts

@@ -0,0 +1,21 @@
+import { Participant } from 'livekit-client';
+/**
+ * The `useParticipantInfo` hook returns the identity, name, and metadata of a given participant.
+ * It requires a `Participant` object passed as property or via the `ParticipantContext`.
+ *
+ * @example
+ * ```tsx
+ * const { identity, name, metadata } = useParticipantInfo({ participant });
+ * ```
+ * @public
+ */
+export interface UseParticipantInfoOptions {
+    participant?: Participant;
+}
+/** @public */
+export declare function useParticipantInfo(props?: UseParticipantInfoOptions): {
+    identity: string | undefined;
+    name: string | undefined;
+    metadata: string | undefined;
+};
+//# sourceMappingURL=useParticipantInfo.d.ts.map

package/dist/hooks/useParticipantInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useParticipantInfo.d.ts","sourceRoot":"","sources":["../../src/hooks/useParticipantInfo.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAKlD;;;;;;;;;GASG;AACH,MAAM,WAAW,yBAAyB;IACxC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,cAAc;AACd,wBAAgB,kBAAkB,CAAC,KAAK,GAAE,yBAA8B;;;;EAavE"}

package/dist/hooks/useParticipantPermissions.d.ts

@@ -0,0 +1,17 @@
+import { ParticipantPermission } from '@livekit/protocol';
+import { Participant } from 'livekit-client';
+/**
+ * The `useParticipantPermissions` hook returns the permissions of a given participant.
+ *
+ * @example
+ * ```tsx
+ * const permissions = useParticipantPermissions({ participant });
+ * ```
+ * @public
+ */
+export interface UseParticipantPermissionsOptions {
+    participant?: Participant;
+}
+/** @public */
+export declare function useParticipantPermissions(options?: UseParticipantPermissionsOptions): ParticipantPermission | undefined;
+//# sourceMappingURL=useParticipantPermissions.d.ts.map

package/dist/hooks/useParticipantPermissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useParticipantPermissions.d.ts","sourceRoot":"","sources":["../../src/hooks/useParticipantPermissions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAKlD;;;;;;;;GAQG;AACH,MAAM,WAAW,gCAAgC;IAC/C,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,cAAc;AACd,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC,GAC7C,qBAAqB,GAAG,SAAS,CAKnC"}

package/dist/hooks/useParticipantTile.d.ts

@@ -0,0 +1,22 @@
+import { ParticipantClickEvent, TrackReferenceOrPlaceholder } from '@livekit/components-core';
+import * as React from 'react';
+/** @public */
+export interface UseParticipantTileProps<T extends HTMLElement> extends React.HTMLAttributes<T> {
+    /** The track reference to display. */
+    trackRef?: TrackReferenceOrPlaceholder;
+    disableSpeakingIndicator?: boolean;
+    onParticipantClick?: (event: ParticipantClickEvent) => void;
+    htmlProps: React.HTMLAttributes<T>;
+}
+/**
+ * The `useParticipantTile` hook is used to implement the `ParticipantTile` and returns the props needed to render the tile.
+ * @remarks
+ * The returned props include many data attributes that are useful for CSS styling purposes because they
+ * indicate the state of the participant and the track.
+ * For example: `data-lk-audio-muted`, `data-lk-video-muted`, `data-lk-speaking`, `data-lk-local-participant`, `data-lk-source`, `data-lk-facing-mode`.
+ * @public
+ */
+export declare function useParticipantTile<T extends HTMLElement>({ trackRef, onParticipantClick, disableSpeakingIndicator, htmlProps, }: UseParticipantTileProps<T>): {
+    elementProps: React.HTMLAttributes<T>;
+};
+//# sourceMappingURL=useParticipantTile.d.ts.map

package/dist/hooks/useParticipantTile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useParticipantTile.d.ts","sourceRoot":"","sources":["../../src/hooks/useParticipantTile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAEnG,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAQ/B,cAAc;AACd,MAAM,WAAW,uBAAuB,CAAC,CAAC,SAAS,WAAW,CAAE,SAAQ,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;IAC7F,sCAAsC;IACtC,QAAQ,CAAC,EAAE,2BAA2B,CAAC;IACvC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAC5D,SAAS,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,WAAW,EAAE,EACxD,QAAQ,EACR,kBAAkB,EAClB,wBAAwB,EACxB,SAAS,GACV,EAAE,uBAAuB,CAAC,CAAC,CAAC;kBA8CpB,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;EAE/B"}

package/dist/hooks/useParticipantTracks.d.ts

@@ -0,0 +1,14 @@
+import { TrackReference } from '@livekit/components-core';
+import { Room, Track } from 'livekit-client';
+type UseParticipantTracksOptions = {
+    participantIdentity?: string;
+    room?: Room;
+};
+/**
+ * `useParticipantTracks` is a custom React that allows you to get tracks of a specific participant only, by specifiying the participant's identity.
+ * If the participant identity is not passed the hook will try to get the participant from a participant context.
+ * @public
+ */
+export declare function useParticipantTracks<TrackSource extends Track.Source>(sources: Array<TrackSource>, optionsOrParticipantIdentity?: UseParticipantTracksOptions | UseParticipantTracksOptions['participantIdentity']): Array<TrackReference>;
+export {};
+//# sourceMappingURL=useParticipantTracks.d.ts.map

package/dist/hooks/useParticipantTracks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useParticipantTracks.d.ts","sourceRoot":"","sources":["../../src/hooks/useParticipantTracks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAG/D,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAIlD,KAAK,2BAA2B,GAAG;IACjC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,IAAI,CAAC,EAAE,IAAI,CAAC;CACb,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,SAAS,KAAK,CAAC,MAAM,EACnE,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,EAC3B,4BAA4B,GACxB,2BAA2B,GAC3B,2BAA2B,CAAC,qBAAqB,CAAM,GAC1D,KAAK,CAAC,cAAc,CAAC,CA8BvB"}

package/dist/hooks/useParticipants.d.ts

@@ -0,0 +1,30 @@
+import { Room, RoomEvent } from 'livekit-client';
+/** @public */
+export interface UseParticipantsOptions {
+    /**
+     * To optimize performance, you can use the `updateOnlyOn` property to decide on what RoomEvents the hook updates.
+     * By default it updates on all relevant RoomEvents to keep the returned participants array up to date.
+     * The minimal set of non-overwriteable `RoomEvents` is: `[RoomEvent.ParticipantConnected, RoomEvent.ParticipantDisconnected, RoomEvent.ConnectionStateChanged]`
+     */
+    updateOnlyOn?: RoomEvent[];
+    /**
+     * The room to use. If not provided, the hook will use the room from the context.
+     */
+    room?: Room;
+}
+/**
+ * The `useParticipants` hook returns all participants (local and remote) of the current room.
+ * @remarks
+ * To optimize performance, you can use the `updateOnlyOn` property to decide on what `RoomEvents` the hook updates.
+ *
+ * @example
+ * ```tsx
+ * const participants = useParticipants();
+ * <ParticipantLoop participants={participants}>
+ *  <ParticipantName />
+ * </ParticipantLoop>
+ * ```
+ * @public
+ */
+export declare function useParticipants(options?: UseParticipantsOptions): (import('livekit-client').RemoteParticipant | import('livekit-client').LocalParticipant)[];
+//# sourceMappingURL=useParticipants.d.ts.map

package/dist/hooks/useParticipants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useParticipants.d.ts","sourceRoot":"","sources":["../../src/hooks/useParticipants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAKtD,cAAc;AACd,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,EAAE,CAAC;IAC3B;;OAEG;IACH,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,8FAQnE"}

package/dist/hooks/usePersistentUserChoices.d.ts

@@ -0,0 +1,35 @@
+import { LocalUserChoices } from '@livekit/components-core';
+/**
+ * Options for the `usePersistentDeviceSettings` hook.
+ * @alpha
+ */
+export interface UsePersistentUserChoicesOptions {
+    /**
+     * The default value to use if reading from local storage returns no results or fails.
+     */
+    defaults?: Partial<LocalUserChoices>;
+    /**
+     * Whether to prevent saving to persistent storage.
+     * @defaultValue false
+     */
+    preventSave?: boolean;
+    /**
+     * Whether to prevent loading user choices from persistent storage and use `defaults` instead.
+     * @defaultValue false
+     */
+    preventLoad?: boolean;
+}
+/**
+ * A hook that provides access to user choices stored in local storage, such as
+ * selected media devices and their current state (on or off), as well as the user name.
+ * @alpha
+ */
+export declare function usePersistentUserChoices(options?: UsePersistentUserChoicesOptions): {
+    userChoices: LocalUserChoices;
+    saveAudioInputEnabled: (isEnabled: boolean) => void;
+    saveVideoInputEnabled: (isEnabled: boolean) => void;
+    saveAudioInputDeviceId: (deviceId: string) => void;
+    saveVideoInputDeviceId: (deviceId: string) => void;
+    saveUsername: (username: string) => void;
+};
+//# sourceMappingURL=usePersistentUserChoices.d.ts.map

package/dist/hooks/usePersistentUserChoices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePersistentUserChoices.d.ts","sourceRoot":"","sources":["../../src/hooks/usePersistentUserChoices.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAIjE;;;GAGG;AACH,MAAM,WAAW,+BAA+B;IAC9C;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACrC;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,+BAAoC;;uCAKxB,OAAO;uCAGP,OAAO;uCAGP,MAAM;uCAGN,MAAM;6BAGhB,MAAM;EAgBzD"}

package/dist/hooks/usePinnedTracks.d.ts

@@ -0,0 +1,14 @@
+import { TrackReferenceOrPlaceholder } from '@livekit/components-core';
+import { LayoutContextType } from '../context';
+/**
+ * The `usePinnedTracks` hook returns a array of the pinned tracks of the current room.
+ * @remarks
+ * To function properly, this hook must be called within a `LayoutContext`.
+ * @example
+ * ```tsx
+ * const pinnedTracks = usePinnedTracks();
+ * ```
+ * @public
+ */
+export declare function usePinnedTracks(layoutContext?: LayoutContextType): TrackReferenceOrPlaceholder[];
+//# sourceMappingURL=usePinnedTracks.d.ts.map

package/dist/hooks/usePinnedTracks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePinnedTracks.d.ts","sourceRoot":"","sources":["../../src/hooks/usePinnedTracks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAE5E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGpD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,aAAa,CAAC,EAAE,iBAAiB,GAAG,2BAA2B,EAAE,CAQhG"}

package/dist/hooks/useRemoteParticipant.d.ts

@@ -0,0 +1,35 @@
+import { ParticipantIdentifier } from '@livekit/components-core';
+import { ParticipantEvent, RemoteParticipant } from 'livekit-client';
+/** @public */
+export interface UseRemoteParticipantOptions {
+    /**
+     * To optimize performance, you can use the `updateOnlyOn` property to decide on what `ParticipantEvents` the hook updates.
+     * By default it updates on all relevant ParticipantEvents to keep the returned participant up to date.
+     */
+    updateOnlyOn?: ParticipantEvent[];
+}
+/**
+ * The `useRemoteParticipant` hook returns the first RemoteParticipant by either identity and/or based on the participant kind.
+ * @remarks
+ * To optimize performance, you can use the `updateOnlyOn` property to decide on what `ParticipantEvents` the hook updates.
+ *
+ * @example
+ * ```tsx
+ * const participant = useRemoteParticipant({kind: ParticipantKind.Agent, identity: 'myAgent'});
+ * ```
+ * @public
+ */
+export declare function useRemoteParticipant(identifier: ParticipantIdentifier, options?: UseRemoteParticipantOptions): RemoteParticipant | undefined;
+/**
+ * The `useRemoteParticipant` hook returns the first RemoteParticipant by either identity or based on the participant kind.
+ * @remarks
+ * To optimize performance, you can use the `updateOnlyOn` property to decide on what `ParticipantEvents` the hook updates.
+ *
+ * @example
+ * ```tsx
+ * const participant = useRemoteParticipant('Russ');
+ * ```
+ * @public
+ */
+export declare function useRemoteParticipant(identity: string, options?: UseRemoteParticipantOptions): RemoteParticipant | undefined;
+//# sourceMappingURL=useRemoteParticipant.d.ts.map

package/dist/hooks/useRemoteParticipant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRemoteParticipant.d.ts","sourceRoot":"","sources":["../../src/hooks/useRemoteParticipant.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAI1E,cAAc;AACd,MAAM,WAAW,2BAA2B;IAC1C;;;OAGG;IACH,YAAY,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,qBAAqB,EACjC,OAAO,CAAC,EAAE,2BAA2B,GACpC,iBAAiB,GAAG,SAAS,CAAC;AACjC;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,2BAA2B,GACpC,iBAAiB,GAAG,SAAS,CAAC"}