@daouy/loader-react 1.0.409

package/dist/index.d.ts

@@ -0,0 +1,728 @@
+import { AssetModule } from '@daouy/loader-core';
+import type { CodeComponentMeta as CodeComponentMeta_2 } from '@daouy/host';
+import { CodeModule } from '@daouy/loader-fetcher';
+import type { ComponentHelpers } from '@daouy/host';
+import { ComponentMeta } from '@daouy/loader-core';
+import { ComponentMeta as ComponentMeta_2 } from '@daouy/loader-fetcher';
+import type { CustomFunctionMeta as CustomFunctionMeta_2 } from '@daouy/host';
+import { DaouyCanvasContext } from '@daouy/host';
+import { DaouyCanvasHost } from '@daouy/host';
+import { DaouyDataSourceContextValue } from '@daouy/data-sources-context';
+import { daouyDataSourcesContext } from '@daouy/data-sources-context';
+import { daouyHost } from '@daouy/host';
+import { DaouyModulesFetcher } from '@daouy/loader-core';
+import { daouyQuery } from '@daouy/query';
+import { DaouyTranslatorContext } from '@daouy/host';
+import { DataCtxReader } from '@daouy/host';
+import { DataProvider } from '@daouy/host';
+import { FontMeta } from '@daouy/loader-core';
+import { getActiveVariation } from '@daouy/loader-splits';
+import { getExternalIds } from '@daouy/loader-splits';
+import { GlobalActionsContext } from '@daouy/host';
+import { GlobalActionsProvider } from '@daouy/host';
+import type { GlobalContextMeta as GlobalContextMeta_2 } from '@daouy/host';
+import { GlobalGroupMeta } from '@daouy/loader-core';
+import { LoaderBundleCache } from '@daouy/loader-core';
+import { LoaderBundleOutput } from '@daouy/loader-fetcher';
+import { LoaderBundleOutput as LoaderBundleOutput_2 } from '@daouy/loader-core';
+import { PageMeta } from '@daouy/loader-core';
+import { PageMetadata } from '@daouy/loader-core';
+import { PageParamsProvider } from '@daouy/host';
+import { PropType } from '@daouy/host';
+import { react } from 'react';
+import * as React_2 from 'react';
+import { default as React_3 } from 'react';
+import { reactDom } from 'react-dom';
+import { reactJsxDevRuntime } from 'react/jsx-dev-runtime';
+import { reactJsxRuntime } from 'react/jsx-runtime';
+import { Registry } from '@daouy/loader-core';
+import { repeatedElement } from '@daouy/host';
+import { Split } from '@daouy/loader-fetcher';
+import type { StateHelpers } from '@daouy/host';
+import type { StateSpec } from '@daouy/host';
+import { TokenRegistration } from '@daouy/host';
+import { TrackRenderOptions } from '@daouy/loader-core';
+import { TraitMeta } from '@daouy/host';
+import { useDaouyCanvasComponentInfo } from '@daouy/host';
+import { useDaouyCanvasContext } from '@daouy/host';
+import { useDaouyQueryData } from '@daouy/query';
+import { useDataEnv } from '@daouy/host';
+import type { useMutableDaouyQueryData } from '@daouy/query';
+import { useSelector } from '@daouy/host';
+import { useSelectors } from '@daouy/host';
+
+/** Subset of loader functionality that works on Client and React Server Components. */
+declare abstract class BaseInternalDaouyComponentLoader {
+    readonly opts: InitOptions;
+    private readonly registry;
+    private readonly fetcher;
+    private readonly onBundleMerged?;
+    private readonly onBundleFetched?;
+    private globalVariants;
+    private subs;
+    private bundle;
+    constructor(args: {
+        opts: InitOptions;
+        fetcher: DaouyModulesFetcher;
+        /** Called after `mergeBundle` (including `fetch` calls). */
+        onBundleMerged?: () => void;
+        /** Called after any `fetch` calls. */
+        onBundleFetched?: () => void;
+        builtinModules: BuiltinRegisteredModules;
+    });
+    private maybeGetCompMetas;
+    maybeFetchComponentData(specs: ComponentLookupSpec[], opts?: FetchComponentDataOpts): Promise<ComponentRenderData | null>;
+    maybeFetchComponentData(...specs: ComponentLookupSpec[]): Promise<ComponentRenderData | null>;
+    fetchComponentData(specs: ComponentLookupSpec[], opts?: FetchComponentDataOpts): Promise<ComponentRenderData>;
+    fetchComponentData(...specs: ComponentLookupSpec[]): Promise<ComponentRenderData>;
+    fetchPages(opts?: FetchPagesOpts): Promise<PageMeta[]>;
+    fetchComponents(): Promise<ComponentMeta_2[]>;
+    getActiveSplits(): Split[];
+    getChunksUrl(bundle: LoaderBundleOutput, modules: CodeModule[]): string;
+    private fetchMissingData;
+    private maybeReportClientSideFetch;
+    private fetchAllData;
+    mergeBundle(newBundle: LoaderBundleOutput): void;
+    getBundle(): LoaderBundleOutput;
+    clearCache(): void;
+    registerModules(modules: Record<string, any>): void;
+    substituteComponent<P>(component: React.ComponentType<P>, name: ComponentLookupSpec): void;
+    protected internalSubstituteComponent<P>(component: React.ComponentType<P>, name: ComponentLookupSpec, codeComponentHelpers: ComponentHelpers<React.ComponentProps<React.ComponentType<P>>> | undefined): void;
+    abstract registerComponent<T extends React.ComponentType<any>>(component: T, meta: CodeComponentMeta<React.ComponentProps<T>>): void;
+    abstract registerFunction<F extends (...args: any[]) => any>(fn: F, meta: CustomFunctionMeta<F>): void;
+    abstract registerGlobalContext<T extends React.ComponentType<any>>(context: T, meta: GlobalContextMeta<React.ComponentProps<T>>): void;
+    abstract registerTrait(trait: string, meta: TraitMeta): void;
+    abstract registerToken(token: TokenRegistration): void;
+    protected refreshRegistry(): void;
+    isRegistryEmpty(): boolean;
+    clearRegistry(): void;
+    setGlobalVariants(globalVariants: GlobalVariantSpec[]): void;
+    getGlobalVariants(): GlobalVariantSpec[];
+    registerPrefetchedBundle(bundle: LoaderBundleOutput): void;
+    getLookup(): ComponentLookup;
+    trackConversion(_value?: number): void;
+    getActiveVariation(opts: Omit<Parameters<typeof getActiveVariation>[0], "splits">): Promise<Record<string, string>>;
+    getTeamIds(): string[];
+    getProjectIds(): string[];
+    trackRender(_opts?: TrackRenderOptions): void;
+    loadServerQueriesModule(fileName: string): any;
+}
+
+declare interface BuiltinRegisteredModules {
+    react: react;
+    "react-dom": reactDom;
+    "react/jsx-runtime": reactJsxRuntime;
+    "react/jsx-dev-runtime": reactJsxDevRuntime;
+    "@daouy/query": daouyQuery;
+    "@daouy/data-sources-context": daouyDataSourcesContext;
+    "@daouy/host": daouyHost;
+    "@daouy/loader-runtime-registry": {
+        components: Record<string, React.ComponentType<any>>;
+        globalVariantHooks: Record<string, () => any>;
+        codeComponentHelpers: Record<string, ComponentHelpers<any>>;
+        functions: Record<string, (...args: any[]) => any>;
+    };
+}
+
+export declare type CodeComponentMeta<P> = Omit<CodeComponentMeta_2<P>, "importPath" | "componentHelpers" | "states"> & {
+    /**
+     * The path to be used when importing the component in the generated code.
+     * It can be the name of the package that contains the component, or the path
+     * to the file in the project (relative to the root directory).
+     * Optional: not used by Daouy headless API, only by codegen.
+     */
+    importPath?: string;
+    /**
+     * The states helpers are registered together with the states for the Daouy headless API
+     */
+    states?: Record<string, StateSpec<P> & StateHelpers<P, any>>;
+    /**
+     * Helper function to enable data extraction when running Daouy from
+     * Next.js App Router.
+     */
+    getServerInfo?: (props: P, ops: ReactServerOps) => ServerInfo;
+};
+
+declare class ComponentLookup {
+    private bundle;
+    private registry;
+    constructor(bundle: LoaderBundleOutput_2, registry: Registry);
+    getComponentMeta(spec: ComponentLookupSpec): ComponentMeta | undefined;
+    getComponent<P extends React_2.ComponentType = any>(spec: ComponentLookupSpec, opts?: {
+        forceOriginal?: boolean;
+    }): any;
+    hasComponent(spec: ComponentLookupSpec): boolean;
+    getGlobalContexts(): {
+        meta: GlobalGroupMeta;
+        context: any;
+    }[];
+    /** Returns StyleTokensProvider if the project has style token overrides. */
+    maybeGetStyleTokensProvider(spec: ComponentLookupSpec, styleTokenOverridesProjectId?: string): any;
+    getGlobalContextsProvider(spec: ComponentLookupSpec): any;
+    getRootProvider(): any;
+    getCss(): AssetModule[];
+    getRemoteFonts(): FontMeta[];
+}
+
+export declare type ComponentLookupSpec = string | {
+    name: string;
+    projectId?: string;
+    isCode?: boolean;
+};
+
+export { ComponentMeta }
+
+export declare interface ComponentRenderData {
+    entryCompMetas: (ComponentMeta_2 & {
+        params?: Record<string, string>;
+    })[];
+    bundle: LoaderBundleOutput;
+    remoteFontUrls: string[];
+}
+
+export declare const convertBundlesToComponentRenderData: (bundles: LoaderBundleOutput_2[], compMetas: ComponentMeta[]) => ComponentRenderData | null;
+
+export declare type CustomFunctionMeta<F extends (...args: any[]) => any> = Omit<CustomFunctionMeta_2<F>, "importPath"> & {
+    /**
+     * The path to be used when importing the function in the generated code.
+     * It can be the name of the package that contains the function, or the path
+     * to the file in the project (relative to the root directory).
+     * Optional: not used by Daouy headless API, only by codegen.
+     */
+    importPath?: string;
+};
+
+export { DaouyCanvasContext }
+
+export { DaouyCanvasHost }
+
+export declare function DaouyComponent(props: {
+    /**
+     * Name of the component to render, or the path of the page component
+     */
+    component: string;
+    /**
+     * Optionally specify a projectId if there are multiple components
+     * of the same name from different projects
+     */
+    projectId?: string;
+    /**
+     * If you used registerComponent(), then if the name matches a registered
+     * component, that component is used.  If you want the Daouy-generated
+     * component instead, specify forceOriginal.
+     */
+    forceOriginal?: boolean;
+    componentProps?: any;
+}): React_2.ReactElement | null;
+
+/**
+ * Library for fetching component data, and registering
+ * custom components.
+ */
+export declare class DaouyComponentLoader {
+    private __internal;
+    constructor(internal: BaseInternalDaouyComponentLoader);
+    /**
+     * Sets global variants to be used for all components.  Note that
+     * this is not reactive, and will not re-render all components
+     * already mounted; instead, it should be used to activate global
+     * variants that should always be activated for the lifetime of this
+     * app.  If you'd like to reactively change the global variants,
+     * you should specify them via <DaouyRootProvider />
+     */
+    setGlobalVariants(globalVariants: GlobalVariantSpec[]): void;
+    registerModules(modules: Record<string, any>): void;
+    /**
+     * Register custom components that should be swapped in for
+     * components defined in your project.  You can use this to
+     * swap in / substitute a Daouy component with a "real" component.
+     */
+    substituteComponent<P>(component: React.ComponentType<P>, name: ComponentLookupSpec): void;
+    /**
+     * Register code components to be used on Daouy Editor.
+     */
+    registerComponent<T extends React.ComponentType<any>>(component: T, meta: CodeComponentMeta<React.ComponentProps<T>>): void;
+    /**
+     * [[deprecated]] Please use `substituteComponent` instead for component
+     * substitution, or the other `registerComponent` overload to register
+     * code components to be used on Daouy Editor.
+     *
+     * @see `substituteComponent`
+     */
+    registerComponent<T extends React.ComponentType<any>>(component: T, name: ComponentLookupSpec): void;
+    private warnedRegisterComponent;
+    registerFunction<F extends (...args: any[]) => any>(fn: F, meta: CustomFunctionMeta<F>): void;
+    registerGlobalContext<T extends React.ComponentType<any>>(context: T, meta: GlobalContextMeta<React.ComponentProps<T>>): void;
+    registerTrait(trait: string, meta: TraitMeta): void;
+    registerToken(token: TokenRegistration): void;
+    /**
+     * Pre-fetches component data needed to for DaouyLoader to render
+     * these components.  Should be passed into DaouyRootProvider as
+     * the prefetchedData prop.
+     *
+     * You can look up a component either by:
+     * - the name of the component
+     * - the path for a page component
+     * - an array of strings that make up parts of the path
+     * - object { name: "name_or_path", projectId: ...}, to specify which project
+     *   to use, if multiple projects have the same component name
+     *
+     * Throws an Error if a specified component to fetch does not exist in
+     * the Daouy project.
+     */
+    fetchComponentData(...specs: ComponentLookupSpec[]): Promise<ComponentRenderData>;
+    fetchComponentData(specs: ComponentLookupSpec[], opts?: FetchComponentDataOpts): Promise<ComponentRenderData>;
+    /**
+     * Like fetchComponentData(), but returns null instead of throwing an Error
+     * when a component is not found.  Useful when you are implementing a catch-all
+     * page and want to check if a specific path had been defined for Daouy.
+     */
+    maybeFetchComponentData(...specs: ComponentLookupSpec[]): Promise<ComponentRenderData | null>;
+    maybeFetchComponentData(specs: ComponentLookupSpec[], opts?: FetchComponentDataOpts): Promise<ComponentRenderData | null>;
+    /**
+     * Returns all the page component metadata for these projects.
+     */
+    fetchPages(opts?: FetchPagesOpts): Promise<PageMeta[]>;
+    /**
+     * Returns all components metadata for these projects.
+     */
+    fetchComponents(): Promise<ComponentMeta_2[]>;
+    protected _getActiveVariation(opts: Parameters<typeof DaouyComponentLoader.__internal.getActiveVariation>[0]): Promise<Record<string, string>>;
+    getActiveVariation(opts: {
+        known?: Record<string, string>;
+        traits: Record<string, string | number | boolean>;
+    }): Promise<Record<string, string>>;
+    getChunksUrl(bundle: LoaderBundleOutput, modules: CodeModule[]): string;
+    getExternalVariation(variation: Record<string, string>, filters?: Parameters<typeof getExternalIds>[2]): Record<string, string>;
+    getActiveSplits(): Split[];
+    trackConversion(value?: number): void;
+    clearCache(): void;
+    getExecFuncModule(renderData: ComponentRenderData, fileNameKey: "serverQueriesExecFuncFileName" | "generateMetadataFuncFileName"): any;
+    unstable__getServerQueriesData(renderData: ComponentRenderData, $ctx: Record<string, any>): Promise<any>;
+    unstable__generateMetadata(renderData: ComponentRenderData, props: {
+        params: Promise<ParamsRecord> | ParamsRecord;
+        query: Promise<ParamsRecord> | ParamsRecord;
+    }): Promise<any>;
+}
+
+/**
+ * @deprecated Maintained for backwards compatibility
+ */
+export declare function daouyPrepass(element: React.ReactElement): Promise<void>;
+
+/**
+ * DaouyRootProvider should be used at the root of your page
+ * or application.
+ */
+export declare function DaouyRootProvider(props: {
+    /**
+     * The global DaouyComponentLoader instance you created via
+     * initDaouyLoader().
+     */
+    loader: DaouyComponentLoader;
+    /**
+     * Global variants to activate for Daouy components
+     */
+    globalVariants?: GlobalVariantSpec[];
+    children?: React_2.ReactNode;
+    /**
+     * If true, will skip rendering css
+     */
+    skipCss?: boolean;
+    /**
+     * If true, will skip installing fonts
+     */
+    skipFonts?: boolean;
+    /**
+     * If you have pre-fetched component data via DaouyComponentLoader,
+     * you can pass them in here; DaouyComponent will avoid fetching
+     * component data that have already been pre-fetched.
+     */
+    prefetchedData?: ComponentRenderData;
+    /**
+     * If you have pre-fetched data that are needed by useDaouyQueryData(),
+     * then pass in the pre-fetched cache here, mapping query key to fetched data.
+     */
+    prefetchedQueryData?: Record<string, any>;
+    /**
+     * Specifies whether useDaouyQueryData() should be operating in suspense mode
+     * (throwing promises).
+     */
+    suspenseForQueryData?: boolean;
+    /**
+     * Override your Global Contexts Provider props. This is a map from
+     * globalContextComponentNameProps to object of props to use for that
+     * component.
+     */
+    globalContextsProps?: Record<string, any>;
+    /**
+     * Specifies a mapping of split id to slice id that should be activated
+     */
+    variation?: Record<string, string>;
+    /**
+     * Translator function to be used for text blocks
+     */
+    translator?: DaouyTranslator;
+    /**
+     * Head component to use in DaouyHead component (e.g. Head from next/head
+     * or Helmet from react-helmet).
+     */
+    Head?: React_2.ComponentType<any>;
+    /**
+     * Link component to use. Can be any component that takes in props passed
+     * to an <a/> tag.
+     */
+    Link?: React_2.ComponentType<any>;
+    /**
+     * Page route without params substitution (e.g. /products/[slug]).
+     */
+    pageRoute?: string;
+    /**
+     * Page path parameters (e.g. {slug: "foo"} if page path is
+     * /products/[slug] and URI is /products/foo).
+     */
+    pageParams?: Record<string, string | string[] | undefined>;
+    /**
+     * Page query parameters (e.g. {q: "foo"} if page path is
+     * /some/path?q=foo).
+     */
+    pageQuery?: Record<string, string | string[] | undefined>;
+    /**
+     * Whether the internal Daouy React.Suspense boundaries should be removed
+     */
+    disableLoadingBoundary?: boolean;
+    /**
+     * Whether the root React.Suspense boundary should be removed
+     */
+    disableRootLoadingBoundary?: boolean;
+    /**
+     * Fallback value for React.Suspense boundary
+     */
+    suspenseFallback?: React_2.ReactNode;
+    /**
+     * When Daouy loads components from multiple projects, we must choose a style token overrides to use that will apply to all components under the root DaouyComponent.
+     *
+     * If styleTokenOverridesProjectId is set, all DaouyComponents and their subtrees will use the specified project's style token overrides.
+     * If styleTokenOverridesProjectId it not set, each DaouyComponent and its subtree will use the style token overrides of the root DaouyComponent's project.
+     */
+    styleTokenOverridesProjectId?: string;
+} & DaouyDataSourceContextValue): React_2.JSX.Element;
+
+declare interface DaouyRootWatcher {
+    onDataFetched?: () => void;
+}
+
+export declare type DaouyTranslator = (str: string, opts?: {
+    components?: {
+        [key: string]: React_2.ReactElement | React_2.ReactFragment;
+    };
+}) => React_2.ReactNode;
+
+export { DaouyTranslatorContext }
+
+export { DataCtxReader }
+
+export { DataProvider }
+
+/**
+ * Performs a prepass over Daouy content, kicking off the necessary
+ * data fetches, and populating the fetched data into a cache.  This
+ * cache can be passed as prefetchedQueryData into DaouyRootProvider.
+ *
+ * To limit rendering errors that can occur when you do this, we recommend
+ * that you pass in _only_ the DaouyComponents that you are planning to use
+ * as the argument.  For example:
+ *
+ *   const cache = await extractDaouyQueryData(
+ *     <DaouyRootProvider loader={DAOUY} prefetchedData={daouyData}>
+ *       <DaouyComponent component="Home" componentProps={{
+ *         // Specify the component prop overrides you are planning to use
+ *         // to render the page, as they may change what data is fetched.
+ *         ...
+ *       }} />
+ *       <DaouyComponent component="NavBar" componentProps={{
+ *         ...
+ *       }} />
+ *       ...
+ *     </DaouyRootProvider>
+ *   );
+ *
+ * If your DaouyComponent will be wrapping components that require special
+ * context set up, you should also wrap the element above with those context
+ * providers.
+ *
+ * You should avoid passing in elements that are not related to Daouy, as any
+ * rendering errors from those elements during the prepass may result in data
+ * not being populated in the cache.
+ *
+ * @param element a React element containing instances of DaouyComponent.
+ *   Will attempt to satisfy all data needs from useDaouyDataQuery()
+ *   in this element tree.
+ * @returns an object mapping query key to fetched data
+ */
+export declare function extractDaouyQueryData(element: React.ReactElement): Promise<Record<string, any>>;
+
+export declare function extractDaouyQueryDataFromElement(loader: DaouyComponentLoader, lookup: ComponentLookupSpec, opts?: {
+    prefetchedData?: ComponentRenderData;
+    componentProps?: any;
+    globalVariants?: GlobalVariantSpec[];
+    prefetchedQueryData?: Record<string, any>;
+}): Promise<Record<string, any>>;
+
+export declare interface FetchComponentDataOpts {
+    /**
+     * Will fetch either code targeting SSR or browser hydration in the
+     * returned bundle.
+     *
+     * By default, the target is browser. That's okay, because even when
+     * doing SSR, as long as you are using the same instance of DaouyLoader
+     * that was used to fetch component data, it will still know how to get at
+     * the server code.
+     *
+     * But, if you are building your own SSR solution, where fetching and rendering
+     * are using different instances of DaouyLoader, then you'll want to make
+     * sure that when you fetch, you are fetching the right one to be used in the
+     * right environment for either SSR or browser hydration.
+     */
+    target?: "server" | "browser";
+}
+
+declare type FetchPagesOpts = {
+    /**
+     * Whether to include dynamic pages in fetchPages() output. A page is
+     * considered dynamic if its path contains some param between brackets,
+     * e.g. "[slug]".
+     */
+    includeDynamicPages?: boolean;
+};
+
+export { GlobalActionsContext }
+
+export { GlobalActionsProvider }
+
+export declare type GlobalContextMeta<P> = Omit<GlobalContextMeta_2<P>, "importPath"> & {
+    /**
+     * The path to be used when importing the component in the generated code.
+     * It can be the name of the package that contains the component, or the path
+     * to the file in the project (relative to the root directory).
+     * Optional: not used by Daouy headless API, only by codegen.
+     */
+    importPath?: string;
+};
+
+export declare interface GlobalVariantSpec {
+    name: string;
+    projectId?: string;
+    value: any;
+}
+
+export declare function hydrateFromElement(loader: DaouyComponentLoader, target: HTMLElement, lookup: ComponentLookupSpec, opts?: {
+    prefetchedData?: ComponentRenderData;
+    componentProps?: any;
+    globalVariants?: GlobalVariantSpec[];
+    prefetchedQueryData?: Record<string, any>;
+}): Promise<void>;
+
+export declare function initDaouyLoader(opts: InitOptions): DaouyComponentLoader;
+
+export declare interface InitOptions {
+    projects: {
+        id: string;
+        token: string;
+        version?: string;
+    }[];
+    cache?: LoaderBundleCache;
+    platform?: "react" | "nextjs" | "gatsby";
+    platformOptions?: {
+        nextjs?: {
+            appDir: boolean;
+        };
+    };
+    preview?: boolean;
+    host?: string;
+    onClientSideFetch?: "warn" | "error";
+    i18n?: {
+        keyScheme: "content" | "hash" | "path";
+        tagPrefix?: string;
+    };
+    /**
+     * @deprecated use i18n.keyScheme instead
+     */
+    i18nKeyScheme?: "content" | "hash";
+    /**
+     * By default, fetchComponentData() and fetchPages() calls cached in memory
+     * with the DaouyComponentLoader instance.  If alwaysFresh is true, then
+     * data is always freshly fetched over the network.
+     */
+    alwaysFresh?: boolean;
+    /**
+     * If true, generated code from the server won't include page metadata tags
+     */
+    skipHead?: boolean;
+    /**
+     * If true, uses browser / node's native fetch
+     */
+    nativeFetch?: boolean;
+    /**
+     * If true, will not redirect to the codegen server automatically, and will
+     * try to reuse the existing bundle in the cache.
+     */
+    manualRedirect?: boolean;
+}
+
+export declare class InternalDaouyComponentLoader extends BaseInternalDaouyComponentLoader {
+    private readonly roots;
+    constructor(opts: InitOptions);
+    registerComponent<T extends React_3.ComponentType<any>>(component: T, meta: CodeComponentMeta<React_3.ComponentProps<T>>): void;
+    registerFunction<F extends (...args: any[]) => any>(fn: F, meta: CustomFunctionMeta<F>): void;
+    registerGlobalContext<T extends React_3.ComponentType<any>>(context: T, meta: GlobalContextMeta<React_3.ComponentProps<T>>): void;
+    registerTrait(trait: string, meta: TraitMeta): void;
+    registerToken(token: TokenRegistration): void;
+    subscribeDaouyRoot(watcher: DaouyRootWatcher): void;
+    unsubscribeDaouyRoot(watcher: DaouyRootWatcher): void;
+    refreshRegistry(): void;
+}
+
+/**
+ * Check if `lookup` resolves to `pagePath`. If it's a match, return an object
+ * containing path params; otherwise, return false.
+ *
+ * For example,
+ * - `matchesPagePath("/hello/[name]", "/hello/world")` -> `{params: {name:
+ *   "world"}}`
+ * - `matchesPagePath("/hello/[name]", "/")` -> `false`
+ * - `matchesPagePath("/hello/[...catchall]", "/hello/a/b/c")` -> `{params: {catchall: ["a", "b", "c"]}}`
+ * - `matchesPagePath("/hello/[[...catchall]]", "/hello/")` -> `{params: {catchall: []}}`
+ * - `matchesPagePath("/", "")` -> `{params: {}}`
+ */
+export declare function matchesPagePath(pattern: string, path: string): false | {
+    params: Record<string, string | string[]>;
+};
+
+export { PageMeta }
+
+export { PageMetadata }
+
+export { PageParamsProvider }
+
+declare type ParamsRecord = Record<string, string | string[] | undefined>;
+
+export { PropType }
+
+/**
+ * Helper functions to describe code component behaviors, in order to allow
+ * data extraction in RSC / Next.js App routing.
+ */
+declare interface ReactServerOps {
+    readDataEnv: typeof useDataEnv;
+    readDataSelector: typeof useSelector;
+    readDataSelectors: typeof useSelectors;
+    /**
+     * The contexts are passed using a key instead of the context provider
+     * Notice it cannot access the default context value if none has been provided,
+     * since React server components cannot create contexts.
+     */
+    readContext: (contextKey: string) => any;
+    /**
+     * Allows data fetching from the code component and caching the result,
+     * which will be stored in the `queryCache` returned by
+     * `extractDaouyQueryData`.
+     */
+    fetchData: typeof useMutableDaouyQueryData;
+}
+
+export declare function renderToElement(loader: DaouyComponentLoader, target: HTMLElement, lookup: ComponentLookupSpec, opts?: {
+    prefetchedData?: ComponentRenderData;
+    componentProps?: any;
+    globalVariants?: GlobalVariantSpec[];
+    prefetchedQueryData?: Record<string, any>;
+    pageParams?: Record<string, any>;
+    pageQuery?: Record<string, any>;
+}): Promise<void>;
+
+export declare function renderToString(loader: DaouyComponentLoader, lookup: ComponentLookupSpec, opts?: {
+    prefetchedData?: ComponentRenderData;
+    componentProps?: any;
+    globalVariants?: GlobalVariantSpec[];
+    prefetchedQueryData?: Record<string, any>;
+}): string;
+
+export { repeatedElement }
+
+/**
+ *  Each child of a code component might receive separate `DataProvider` and
+ *  Context values.
+ */
+declare interface ServerChildData {
+    providedData?: ServerProvidedData | ServerProvidedData[];
+    providedContexts?: ServerProvidedContext | ServerProvidedContext[];
+    node: React.ReactNode;
+}
+
+declare interface ServerInfo {
+    /**
+     * Optional: Indicates the React Nodes created by the component and the
+     * respective contexts provided to them. If not specified, it will render the
+     * children passed to the component as props.
+     */
+    children?: ServerChildData | ServerChildData[];
+    providedData?: ServerProvidedData | ServerProvidedData[];
+    providedContexts?: ServerProvidedContext | ServerProvidedContext[];
+}
+
+/**
+ * Provides a new value for a given context key, similar to Context.Provider.
+ * The context itself is not available (RSC doesn't allow calling
+ * `createContext`) so each context will need to be represented as a unique
+ * "context key". Also it means the default context value is not available
+ * in case no value is passed (and reading that context will return `undefined`)
+ */
+declare interface ServerProvidedContext {
+    /**
+     * Identifier to the context, required to read it later via
+     * `ReactServerOps.readContext()`.
+     */
+    contextKey: string;
+    /**
+     * Context value being provided (similar to `Context.Provider`).
+     */
+    value: any;
+}
+
+/**
+ * Represents data provided by a code component via `DataProvider`
+ */
+declare interface ServerProvidedData {
+    name: string;
+    data: any;
+}
+
+export { TokenRegistration }
+
+export { useDaouyCanvasComponentInfo }
+
+export { useDaouyCanvasContext }
+
+/**
+ * Hook that fetches and returns a React component for rendering the argument
+ * Daouy component.  Returns undefined if the component data is still
+ * being fetched.
+ *
+ * @param opts.forceOriginal if you used DaouyComponentLoader.registerComponent,
+ *   then normally useDaouyComponent will return the registered component.
+ *   You can set forceOriginal to true if you want to return the Daouy-generated
+ *   component instead.
+ */
+export declare function useDaouyComponent<P extends React_2.ComponentType = any>(spec: ComponentLookupSpec, opts?: {
+    forceOriginal?: boolean;
+}): P;
+
+export { useDaouyQueryData }
+
+export { useDataEnv }
+
+export { useSelector }
+
+export { useSelectors }
+
+export { }