@noya-app/noya-multiplayer-react 0.1.70 → 0.1.72

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as _noya_app_state_manager from '@noya-app/state-manager';
-import { AIToolDefinition, ConnectedUsersManager, EphemeralUserDataManager, NoyaManager, StateManagerOptions, StateManager, NoyaManagerOptions, SyncAdapter, TSchema, Static, PublishCallback, ResourceManager, StreamFilter, ActivityEventsManager, MultiplayerPatchMetadata, SafeEval, CreateParams, MultiplayerStateManager, ReconnectingWebSocketState, ClientToServerMessage, ServerToClientMessage, MultiplayerStateManagerError } from '@noya-app/state-manager';
+import { AIToolDefinition, UserManager, SharedConnectionDataManager, NoyaManager, StateManagerOptions, StateManager, NoyaManagerOptions, SyncAdapter, TSchema, AccessType, PolicyAuthContext, LocalStorageSyncOptions, Static, ExtractRequestBody, PublishCallback, ResourceManager, TranscriptionManager, AssetTranscriptionResult, StreamFilter, ActivityEventsManager, MultiplayerPatchMetadata, SafeEval, CreateParams, MultiplayerStateManager, ReconnectingWebSocketState, ClientToServerMessage, ServerToClientMessage, MultiplayerStateManagerError } from '@noya-app/state-manager';
 export * from '@noya-app/state-manager';
 import React, { SetStateAction, ComponentProps, Dispatch } from 'react';
-import { Asset, ResourceCreate, CreateResourceParametersWithoutAccessibleByFileId, ModifiedResource, ResourceCreateMap, ResourceMap, Resource, MediaItem, OutputTransform, Input } from '@noya-app/noya-schemas';
+import { Asset, ResourceCreate, CreateResourceParametersWithoutAccessibleByFileId, ModifiedResource, Resource, MediaItem, ResourceMap, ResourceCreateMap, OutputTransform, Input } from '@noya-app/noya-schemas';
 import { Root } from 'react-dom/client';
 import { MenuItem } from '@noya-app/noya-designsystem';
 import { ObservableOptions, PathKey, GetAtPath, Observable } from '@noya-app/observable';
@@ -27,8 +27,8 @@ type RenderUserPointer = {
     renderUserPointer: (options: RenderUserPointerProps) => React.ReactNode;
 };
 type UserPointersOverlayProps<E extends UserPointerData> = {
-    connectedUsersManager: ConnectedUsersManager;
-    ephemeralUserDataManager: EphemeralUserDataManager<E>;
+    userManager: UserManager;
+    sharedConnectionDataManager: SharedConnectionDataManager<E>;
 } & RenderUserPointer;
 declare const UserPointersOverlay: <E extends UserPointerData>(props: UserPointersOverlayProps<E>) => React.ReactElement<any> | null;
 
@@ -36,24 +36,25 @@ type StateInspectorAnchor = "left" | "right" | "bottom left" | "bottom right";
 type StateInspectorOptions = {
     colorScheme?: "light" | "dark";
     anchor?: StateInspectorAnchor;
+    advanced?: boolean;
 };
-declare const StateInspector: <S, M extends object, E extends object, MenuT extends string = string>(props: {
-    noyaManager: NoyaManager<S, M, E, MenuT>;
+declare const StateInspector: <S, M extends object, E extends object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>>(props: {
+    noyaManager: NoyaManager<S, M, E, MenuT, I>;
     unstyled?: boolean;
 } & StateInspectorOptions & Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">) => React.ReactElement<any> | null;
 
 declare function useManagedState<S, M = void>(createInitialState: () => S, options?: StateManagerOptions<S, M>): readonly [S, (...args: M extends {} ? [metadata: M, action: SetStateAction<S>] : [action: SetStateAction<S>]) => void, StateManager<S, M>];
 declare function useManagedHistory<S, M = void>(stateManager: StateManager<S, M>): _noya_app_state_manager.HistorySnapshot<S, M>;
-type UseMultiplayerStateOptions<S, M extends object = object, E extends object = object, MenuT extends string = string> = NoyaManagerOptions<S, M> & {
-    sync?: SyncAdapter<S, M, E, MenuT>;
+type UseMultiplayerStateOptions<S, M extends object = object, E extends object = object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>> = NoyaManagerOptions<S, M> & {
+    sync?: SyncAdapter<S, M, E, MenuT, I>;
     inspector?: boolean | StateInspectorOptions;
 };
-declare function useBindNoyaManager<S, M extends object = object, E extends object = object, MenuT extends string = string>(noyaManager: NoyaManager<S, M, E, MenuT>, options?: Pick<UseMultiplayerStateOptions<S, M, E, MenuT>, "inspector" | "sync">): readonly [S, (...args: [metadata: Partial<M>, action: S | ((prevState: S) => S)] | [action: S | ((prevState: S) => S)]) => void, {
+declare function useBindNoyaManager<S, M extends object = object, E extends object = object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>>(noyaManager: NoyaManager<S, M, E, MenuT, I>, options?: Pick<UseMultiplayerStateOptions<S, M, E, MenuT, I>, "inspector" | "sync">): readonly [S, (...args: [metadata: Partial<M>, action: S | ((prevState: S) => S)] | [action: S | ((prevState: S) => S)]) => void, {
     noyaManager: typeof noyaManager;
     taskManager: typeof noyaManager.taskManager;
     connectionEventManager: typeof noyaManager.connectionEventManager;
-    connectedUsersManager: typeof noyaManager.connectedUsersManager;
-    ephemeralUserDataManager: typeof noyaManager.ephemeralUserDataManager;
+    userManager: typeof noyaManager.userManager;
+    sharedConnectionDataManager: typeof noyaManager.sharedConnectionDataManager;
     multiplayerStateManager: typeof noyaManager.multiplayerStateManager;
     assetManager: typeof noyaManager.assetManager;
     aiManager: typeof noyaManager.aiManager;
@@ -75,12 +76,12 @@ declare function useBindNoyaManager<S, M extends object = object, E extends obje
         userId: string | null;
     }[];
 }];
-declare function useMultiplayerState<S, M extends object = object, E extends object = object, MenuT extends string = string>(initialState: S | (() => S), options?: UseMultiplayerStateOptions<S, M, E, MenuT>): readonly [S, (...args: [metadata: Partial<M>, action: S | ((prevState: S) => S)] | [action: S | ((prevState: S) => S)]) => void, {
-    noyaManager: NoyaManager<S, M, E, MenuT>;
+declare function useMultiplayerState<S, M extends object = object, E extends object = object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>>(initialState: S | (() => S), options?: UseMultiplayerStateOptions<S, M, E, MenuT, I>): readonly [S, (...args: [metadata: Partial<M>, action: S | ((prevState: S) => S)] | [action: S | ((prevState: S) => S)]) => void, {
+    noyaManager: NoyaManager<S, M, E, MenuT, I>;
     taskManager: _noya_app_state_manager.TaskManager;
     connectionEventManager: _noya_app_state_manager.ConnectionEventManager<S>;
-    connectedUsersManager: _noya_app_state_manager.ConnectedUsersManager;
-    ephemeralUserDataManager: _noya_app_state_manager.EphemeralUserDataManager<E>;
+    userManager: _noya_app_state_manager.UserManager;
+    sharedConnectionDataManager: _noya_app_state_manager.SharedConnectionDataManager<E>;
     multiplayerStateManager: _noya_app_state_manager.MultiplayerStateManager<S, M>;
     assetManager: _noya_app_state_manager.AssetManager;
     aiManager: _noya_app_state_manager.AIManager;
@@ -104,14 +105,14 @@ declare function useMultiplayerState<S, M extends object = object, E extends obj
 }];
 
 declare function fetchAssetMap(assets: Asset[]): Promise<Record<string, Uint8Array>>;
-declare function exportAll(noyaManager: NoyaManager<any, any, any, any>): Promise<Uint8Array>;
+declare function exportAll(noyaManager: NoyaManager<any, any, any, any, any>): Promise<Uint8Array>;
 declare function encodeAll({ state, schema, assets, assetMap, }: {
     state: unknown;
     schema?: TSchema;
     assets: Asset[];
     assetMap: Record<string, Uint8Array>;
 }): Uint8Array;
-declare function importAll(buffer: Uint8Array | ArrayBuffer, noyaManager: NoyaManager<any, any, any, any>, { shouldAllowSchemaChange, }?: {
+declare function importAll(buffer: Uint8Array | ArrayBuffer, noyaManager: NoyaManager<any, any, any, any, any>, { shouldAllowSchemaChange, }?: {
     shouldAllowSchemaChange?: ({ oldSchema, newSchema, }: {
         oldSchema: TSchema;
         newSchema: TSchema;
@@ -129,10 +130,13 @@ declare function createStateInspectorRoot(): {
     root: Root;
     unmount: () => void;
 };
-declare function useStateInspector<S, M extends object, E extends object, MenuT extends string = string>({ noyaManager, disabled, colorScheme, anchor, }: {
-    noyaManager: NoyaManager<S, M, E, MenuT>;
-    disabled: boolean;
-} & Pick<ComponentProps<typeof StateInspector>, "colorScheme" | "anchor">): void;
+declare function useStateInspector<S, M extends object, E extends object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>>({ noyaManager, disabled, advanced, colorScheme, anchor, }: {
+    noyaManager: NoyaManager<S, M, E, MenuT, I>;
+    disabled?: boolean;
+    advanced?: boolean;
+    colorScheme?: ComponentProps<typeof StateInspector>["colorScheme"];
+    anchor?: ComponentProps<typeof StateInspector>["anchor"];
+}): void;
 
 type AppViewType = "editable" | "readOnly" | "preview";
 type AppTheme = "light" | "dark";
@@ -142,6 +146,9 @@ type AppData<State> = {
     viewType: AppViewType;
     initialState: State;
     inspector: boolean | StateInspectorOptions;
+    userId?: string;
+    isDemo: boolean;
+    access?: AccessType;
 };
 declare function createDefaultAppData<State>(initialState: State): AppData<State>;
 type GetAppDataOptions = {
@@ -155,20 +162,23 @@ type GetAppDataOptions = {
 declare function enforceSchema<State>(initialState: State, schema?: TSchema): State;
 declare function parseAppDataParameter(options?: GetAppDataOptions): AppData<unknown> | null;
 declare function getAppData<State>(initialState: State | (() => State), schema?: TSchema, options?: GetAppDataOptions): AppData<State>;
-declare function getSyncAdapter<S, M extends object = object, E extends object = object, MenuT extends string = string>(params?: {
+declare function getSyncAdapter<S, M extends object = object, E extends object = object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>>(params?: {
     multiplayerUrl?: string;
     offlineStorageKey?: string;
     debug?: boolean;
-}): SyncAdapter<S, M, E, MenuT>;
-type UseNoyaStateOptions<S, M extends object = object, E extends object = object, MenuT extends string = string> = UseMultiplayerStateOptions<S, M, E, MenuT> & {
+    policyAuthContext?: PolicyAuthContext;
+    serverScripts?: LocalStorageSyncOptions["serverScripts"];
+}): SyncAdapter<S, M, E, MenuT, I>;
+type UseNoyaStateOptions<S, M extends object = object, E extends object = object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>> = UseMultiplayerStateOptions<S, M, E, MenuT, I> & {
     offlineStorageKey?: string;
 };
-type UseNoyaStateResult<S, M extends object = object, E extends object = object, MenuT extends string = string> = [
-    ReturnType<typeof useBindNoyaManager<S, M, E, MenuT>>[0],
-    ReturnType<typeof useBindNoyaManager<S, M, E, MenuT>>[1],
-    ReturnType<typeof useBindNoyaManager<S, M, E, MenuT>>[2] & {
+type UseNoyaStateResult<S, M extends object = object, E extends object = object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>> = [
+    ReturnType<typeof useBindNoyaManager<S, M, E, MenuT, I>>[0],
+    ReturnType<typeof useBindNoyaManager<S, M, E, MenuT, I>>[1],
+    ReturnType<typeof useBindNoyaManager<S, M, E, MenuT, I>>[2] & {
         theme: AppTheme;
         viewType: AppViewType;
+        isDemo: boolean;
     }
 ];
 /**
@@ -180,38 +190,34 @@ type UseNoyaStateResult<S, M extends object = object, E extends object = object,
  * 2. Pass an initial state and a schema: `useNoyaState(initialState, { schema })`
  * 3. Pass only a schema, and a conforming initial state is created automatically: `useNoyaState({ schema })`
  */
-declare function useNoyaStateInternal<S, M extends object = object, E extends object = object, MenuT extends string = string, O extends UseNoyaStateOptions<S, M, E, MenuT> = UseNoyaStateOptions<S, M, E, MenuT>>(...args: [
+declare function useNoyaStateInternal<S, M extends object = object, E extends object = object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>, O extends UseNoyaStateOptions<S, M, E, MenuT, I> = UseNoyaStateOptions<S, M, E, MenuT, I>>(...args: [
     initialState: O["schema"] extends TSchema ? Static<O["schema"]> | (() => Static<O["schema"]>) : S | (() => S),
     options?: O
 ] | [options: O & {
     schema: TSchema;
-}]): UseNoyaStateResult<O["schema"] extends TSchema ? Static<O["schema"]> : S, M, E, MenuT>;
+}]): UseNoyaStateResult<O["schema"] extends TSchema ? Static<O["schema"]> : S, M, E, MenuT, I>;
 
 declare function resourceToCreateParameters(resource: ResourceCreate): CreateResourceParametersWithoutAccessibleByFileId;
-type BuildCreateResourcePayloadParameters = {
+type ResourcePatchRequestBody = ExtractRequestBody<"PATCH /api/resources">;
+type BuildResourcePatchPayloadParameters = {
     addedResources: ResourceCreate[];
     modifiedResources: ModifiedResource[];
-    newResourceMap: ResourceCreateMap;
-    resourceMap: ResourceMap;
+    removedResources: Resource[];
 };
-type BuildCreateResourcePayloadResult = {
-    payload: CreateResourceParametersWithoutAccessibleByFileId[];
-    consumedModifiedResourceIds: string[];
-};
-declare function buildCreateResourcePayload({ addedResources, modifiedResources, newResourceMap, resourceMap, }: BuildCreateResourcePayloadParameters): BuildCreateResourcePayloadResult;
-interface NoyaStateProviderProps<S, M extends object, E extends object, MenuT extends string> extends Omit<UseNoyaStateOptions<S, M, E, MenuT>, "schema" | "mergeHistoryEntries"> {
+declare function buildResourcePatchPayload({ addedResources, modifiedResources, removedResources, }: BuildResourcePatchPayloadParameters): ResourcePatchRequestBody;
+interface NoyaStateProviderProps<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>> extends Omit<UseNoyaStateOptions<S, M, E, MenuT, I>, "schema" | "mergeHistoryEntries"> {
     children: React.ReactNode;
     initialState?: S;
     fallback?: React.ReactNode;
 }
 type AnyNoyaStateContextValue = {
-    noyaManager: NoyaManager<any, any, any, any>;
+    noyaManager: NoyaManager<any, any, any, any, any>;
     theme: AppTheme;
     viewType: AppViewType;
 };
 declare const AnyNoyaStateContext: React.Context<AnyNoyaStateContextValue | undefined>;
 declare function useAnyNoyaStateContext(): AnyNoyaStateContextValue;
-declare function useAnyNoyaManager(): NoyaManager<any, any, any, any>;
+declare function useAnyNoyaManager(): NoyaManager<any, any, any, any, any>;
 declare function useColorScheme(): AppTheme;
 declare function useViewType(): AppViewType;
 declare function useAssets(): {
@@ -375,16 +381,36 @@ declare function useIOManager(): _noya_app_state_manager.IOManager;
 declare function usePublish(callback: PublishCallback): void;
 declare function useIsInitialized(): boolean;
 declare function usePipelineManager(): _noya_app_state_manager.PipelineManager;
-declare function useConnectedUsersManager(): _noya_app_state_manager.ConnectedUsersManager;
+declare function useUserManager(): _noya_app_state_manager.UserManager;
 declare function useConnectedUsers(): _noya_app_state_manager.MultiplayerUser[];
 declare function useConnectedUser(userId?: string | null): _noya_app_state_manager.MultiplayerUser | undefined;
-declare function useAnyEphemeralUserData(): EphemeralUserDataManager<any>;
-declare function useCurrentUserId(): string | undefined;
+declare function useAnySharedConnectionData(): SharedConnectionDataManager<any>;
+declare function useEnqueueInput<I extends Record<string, any> = Record<string, unknown>>(): NoyaManager<any, any, any, any, I>["enqueueInput"];
+declare function useNoyaUser(): _noya_app_state_manager.MultiplayerUser | undefined;
+declare function useNoyaId(): string | undefined;
+declare function useNoyaUserId(): string | undefined;
+declare function useNoyaConnectionId(): string | undefined;
+declare function useNoyaClientId(): string | undefined;
 declare function useIsProcessing(): boolean;
 declare function useFileName(): string | undefined;
 declare function useFilePropertyManager(): _noya_app_state_manager.FilePropertyManager;
 declare function useSetFileNameState(): readonly [string | undefined, (name: string) => Promise<string>];
 declare function useResourceManager(): ResourceManager;
+declare function useNoyaTranscriptionManager(): TranscriptionManager;
+type UseNoyaAssetTranscriptionOptions = {
+    endpoint?: string;
+    apiKey?: string;
+};
+/**
+ * Returns a text transcription for the given assetId.
+ *
+ * - This API is available when running your app on noya.io, not when running it locally.
+ * - An asset must first be uploaded via the `useAssetManager().create()` method before
+ *   it can be transcribed via this API.
+ * - The asset must be a valid audio or video file.
+ */
+declare function useNoyaAssetTranscription(assetId: string, options?: UseNoyaAssetTranscriptionOptions): AssetTranscriptionResult;
+declare function useNoyaAssetTranscription(assetId?: string, options?: UseNoyaAssetTranscriptionOptions): AssetTranscriptionResult | undefined;
 declare function resourceToMediaItem(resource: Resource): MediaItem;
 declare function useResources({ shouldDeleteAssets, }?: {
     shouldDeleteAssets?: boolean;
@@ -395,15 +421,15 @@ declare const FallbackUntilInitialized: ({ children, fallback, }: {
     children: React.ReactNode;
     fallback?: React.ReactNode;
 }) => React.ReactNode;
-declare function createNoyaContext<Schema extends TSchema, M extends object = object, E extends object = object, MenuT extends string = string>({ schema, mergeHistoryEntries, outputTransforms, inputs, safeEval, }: {
+declare function createNoyaContext<Schema extends TSchema, M extends object = object, E extends object = object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>>({ schema, mergeHistoryEntries, outputTransforms, inputs, safeEval, }: {
     schema: Schema;
     mergeHistoryEntries?: StateManagerOptions<Static<Schema>, M & Pick<MultiplayerPatchMetadata, "name" | "timestamp">>["mergeHistoryEntries"];
     safeEval?: SafeEval;
     outputTransforms?: CreateParams<OutputTransform>[];
     inputs?: CreateParams<Input>[];
 }): {
-    Context: React.Context<NoyaManager<Static<Schema>, M, E, string> | undefined>;
-    Provider: ({ children, initialState, ...options }: NoyaStateProviderProps<Static<Schema>, M, E, MenuT>) => React.JSX.Element;
+    Context: React.Context<NoyaManager<Static<Schema>, M, E, MenuT, I> | undefined>;
+    Provider: ({ children, initialState, ...options }: NoyaStateProviderProps<Static<Schema>, M, E, MenuT, I>) => React.JSX.Element;
     NoyaContextProvider: ({ children, contextValue, }: {
         children: React.ReactNode;
         contextValue: AnyNoyaStateContextValue;
@@ -423,14 +449,14 @@ declare function createNoyaContext<Schema extends TSchema, M extends object = ob
         <P extends PathKey[] | string>(path?: P): [GetAtPath<Static<Schema>, P>, (...args: [metadata: Partial<M & Pick<MultiplayerPatchMetadata, "name" | "timestamp">>, value: SetStateAction<GetAtPath<Static<Schema>, P>>] | [value: SetStateAction<GetAtPath<Static<Schema>, P>>]) => void];
     };
     useStateManager: () => MultiplayerStateManager<Static<Schema>, Partial<M & Pick<MultiplayerPatchMetadata, "name" | "timestamp">>>;
-    useEphemeralUserDataManager: () => EphemeralUserDataManager<E>;
+    useSharedConnectionDataManager: () => SharedConnectionDataManager<E>;
     useLeftMenuItems: () => MenuItem<MenuT>[];
     useSetLeftMenuItems: (leftMenuItems?: MenuItem<MenuT>[]) => void;
     useRightMenuItems: () => MenuItem<MenuT>[];
     useSetRightMenuItems: (rightMenuItems?: MenuItem<MenuT>[]) => void;
     useHandleMenuItem: (callback: (type: MenuT) => void) => void;
     useOnSelectMenuItemCallback: () => (type: MenuT) => void;
-    useNoyaManager: () => NoyaManager<Static<Schema>, Partial<M & Pick<MultiplayerPatchMetadata, "name" | "timestamp">>, E, MenuT>;
+    useNoyaManager: () => NoyaManager<Static<Schema>, Partial<M & Pick<MultiplayerPatchMetadata, "name" | "timestamp">>, E, MenuT, I>;
     useMenu: (options: {
         leftMenuItems?: MenuItem<MenuT>[];
         rightMenuItems?: MenuItem<MenuT>[];
@@ -439,22 +465,25 @@ declare function createNoyaContext<Schema extends TSchema, M extends object = ob
 };
 
 type AnyNoyaSingletonBindings = {
-    sync?: SyncAdapter<any, any, any, any>;
+    sync?: SyncAdapter<any, any, any, any, any>;
     inspector?: boolean | StateInspectorOptions;
     theme: AppTheme;
     viewType: AppViewType;
+    userId?: string;
+    isDemo: boolean;
 };
-type AnyNoyaSingletonOptions<S, M extends object, E extends object, MenuT extends string> = NoyaManagerOptions<S, M> & {
+type AnyNoyaSingletonOptions<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>> = NoyaManagerOptions<S, M> & {
     initialState?: S | (() => S);
-    sync?: SyncAdapter<S, M, E, MenuT>;
+    sync?: SyncAdapter<S, M, E, MenuT, I>;
     inspector?: boolean | StateInspectorOptions;
     theme?: AppTheme;
     viewType?: AppViewType;
     offlineStorageKey?: string;
     multiplayerUrl?: string;
+    serverScripts?: LocalStorageSyncOptions["serverScripts"];
 };
-declare function initializeNoyaSingleton<S, M extends object, E extends object, MenuT extends string>(options?: AnyNoyaSingletonOptions<S, M, E, MenuT>): void;
-declare function getNoyaManagerSingleton(): NoyaManager<any, any, any, any>;
+declare function initializeNoyaSingleton<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>>(options?: AnyNoyaSingletonOptions<S, M, E, MenuT, I>): void;
+declare function getNoyaManagerSingleton(): NoyaManager<any, any, any, any, any>;
 declare function getNoyaSingletonBindings(): AnyNoyaSingletonBindings | undefined;
 declare function deleteNoyaSingleton(): void;
 
@@ -498,4 +527,4 @@ declare class WebSocketConnection<State> {
     removeListener(listener: (state: ReconnectingWebSocketState) => void): void;
 }
 
-export { type AnyNoyaSingletonBindings, type AnyNoyaSingletonOptions, AnyNoyaStateContext, type AnyNoyaStateContextValue, type AppData, type AppTheme, type AppViewType, type ConnectionEvent, type ConnectionOptions, FallbackUntilInitialized, type GetAppDataOptions, type NoyaStateProviderProps, type RenderUserPointer, type RenderUserPointerProps, StateInspector, type StateInspectorAnchor, type StateInspectorOptions, type UseMultiplayerStateOptions, type UseNoyaStateOptions, type UseNoyaStateResult, type UserPointerData, UserPointersOverlay, type UserPointersOverlayProps, WebSocketConnection, buildCreateResourcePayload, createDefaultAppData, createNoyaContext, createStateInspectorRoot, decodeAll, deleteNoyaSingleton, encodeAll, enforceSchema, exportAll, fetchAssetMap, getAppData, getNoyaManagerSingleton, getNoyaSingletonBindings, getSyncAdapter, importAll, initializeNoyaSingleton, parseAppDataParameter, replaceDeep, resourceToCreateParameters, resourceToMediaItem, useAIManager, useActivityEvents, useActivityEventsForManager, useAnyEphemeralUserData, useAnyNoyaManager, useAnyNoyaStateContext, useAsset, useAssetManager, useAssets, useBindNoyaManager, useCallableAITools, useColorScheme, useConnectedUser, useConnectedUsers, useConnectedUsersManager, useCurrentUserId, useFileName, useFilePropertyManager, useIOManager, useInputs, useIsInitialized, useIsProcessing, useManagedHistory, useManagedState, useMultiplayerState, useNoyaStateInternal, useObservable, useOutputTransforms, usePipelineManager, usePublish, useRegisterAITool, useResourceManager, useResources, useSecret, useSecretManager, useSecrets, useSetFileNameState, useStateInspector, useViewType };
+export { type AnyNoyaSingletonBindings, type AnyNoyaSingletonOptions, AnyNoyaStateContext, type AnyNoyaStateContextValue, type AppData, type AppTheme, type AppViewType, type ConnectionEvent, type ConnectionOptions, FallbackUntilInitialized, type GetAppDataOptions, type NoyaStateProviderProps, type RenderUserPointer, type RenderUserPointerProps, StateInspector, type StateInspectorAnchor, type StateInspectorOptions, type UseMultiplayerStateOptions, type UseNoyaStateOptions, type UseNoyaStateResult, type UserPointerData, UserPointersOverlay, type UserPointersOverlayProps, WebSocketConnection, buildResourcePatchPayload, createDefaultAppData, createNoyaContext, createStateInspectorRoot, decodeAll, deleteNoyaSingleton, encodeAll, enforceSchema, exportAll, fetchAssetMap, getAppData, getNoyaManagerSingleton, getNoyaSingletonBindings, getSyncAdapter, importAll, initializeNoyaSingleton, parseAppDataParameter, replaceDeep, resourceToCreateParameters, resourceToMediaItem, useAIManager, useActivityEvents, useActivityEventsForManager, useAnyNoyaManager, useAnyNoyaStateContext, useAnySharedConnectionData, useAsset, useAssetManager, useAssets, useBindNoyaManager, useCallableAITools, useColorScheme, useConnectedUser, useConnectedUsers, useEnqueueInput, useFileName, useFilePropertyManager, useIOManager, useInputs, useIsInitialized, useIsProcessing, useManagedHistory, useManagedState, useMultiplayerState, useNoyaAssetTranscription, useNoyaClientId, useNoyaConnectionId, useNoyaId, useNoyaStateInternal, useNoyaTranscriptionManager, useNoyaUser, useNoyaUserId, useObservable, useOutputTransforms, usePipelineManager, usePublish, useRegisterAITool, useResourceManager, useResources, useSecret, useSecretManager, useSecrets, useSetFileNameState, useStateInspector, useUserManager, useViewType };