import { CanvasClient, RouteClient, ResolvedRouteGetResponse, CompositionGetBySlugParameters, RouteGetParameters } from '@uniformdev/canvas';
import { UniformServerConfig, CompositionContext, AppDirectoryContextState, AppDirectoryServerContext, PlaygroundParameters, AwaitedPageParameters, PageParameters } from '@uniformdev/canvas-next-rsc-shared';
export { PageParameters, PlaygroundParameters } from '@uniformdev/canvas-next-rsc-shared';
import { ManifestClient } from '@uniformdev/context/api';
import { ProjectMapClient, ProjectMapNode } from '@uniformdev/project-map';
import { ContextState, ContextOptions } from '@uniformdev/context';
import React, { PropsWithChildren } from 'react';
import { U as UniformCompositionProps } from './UniformComposition-CfpHU4f0.js';
export { b as UniformComposition, r as resolveComposition } from './UniformComposition-CfpHU4f0.js';
import { ClientContextComponent } from '@uniformdev/canvas-next-rsc-client';

type GetCanvasClientOptions = {
    cache: NonNullable<UniformServerConfig['canvasCache']>;
};
declare const getCanvasClient: (options: GetCanvasClientOptions) => CanvasClient;
declare const getDefaultCanvasClient: (options: Pick<CompositionContext, "searchParams">) => Promise<CanvasClient>;

type GetManifestClientOptions = {
    cache: NonNullable<UniformServerConfig['manifestCache']>;
};
declare const getManifestClient: (options: GetManifestClientOptions) => ManifestClient;
declare const getDefaultManifestClient: (options: Pick<CompositionContext, "searchParams">) => Promise<ManifestClient>;
declare const getManifest: (options: Pick<CompositionContext, "searchParams">) => Promise<{
    project: {
        id?: string;
        name?: string;
        ui_version?: number;
        pz?: {
            sig?: {
                [key: string]: {
                    str: number;
                    cap: number;
                    dur: "s" | "p" | "t";
                    crit: {
                        type: "G";
                        op?: "&" | "|";
                        clauses: ({
                            type: "G";
                            op?: "&" | "|";
                            clauses: (/*elided*/ any | ({
                                type: "CK";
                                cookieName: string;
                                match: {
                                    rhs: string;
                                    op: "=" | "~" | "//" | "!=" | "!~" | "!//";
                                    cs?: boolean;
                                } | {
                                    op: "*" | "!*";
                                };
                            } | {
                                type: "QS";
                                queryName: string;
                                match: {
                                    rhs: string;
                                    op: "=" | "~" | "//" | "!=" | "!~" | "!//";
                                    cs?: boolean;
                                } | {
                                    op: "*" | "!*";
                                };
                            } | {
                                type: "QK";
                                key: string;
                                match: {
                                    rhs: string;
                                    op: "=" | "~" | "//" | "!=" | "!~" | "!//";
                                    cs?: boolean;
                                } | {
                                    op: "*" | "!*";
                                };
                            } | {
                                type: "EVT";
                                event: {
                                    rhs: string;
                                    op: "=" | "~" | "//" | "!=" | "!~" | "!//";
                                    cs?: boolean;
                                } | {
                                    op: "*" | "!*";
                                };
                            } | {
                                type: "PV";
                                path: {
                                    rhs: string;
                                    op: "=" | "~" | "//" | "!=" | "!~" | "!//";
                                    cs?: boolean;
                                } | {
                                    op: "*" | "!*";
                                };
                            } | {
                                type: "PVC";
                                match: {
                                    rhs: number;
                                    op: "=" | "<" | ">" | "!=";
                                };
                            }))[];
                        } | ({
                            type: "CK";
                            cookieName: string;
                            match: {
                                rhs: string;
                                op: "=" | "~" | "//" | "!=" | "!~" | "!//";
                                cs?: boolean;
                            } | {
                                op: "*" | "!*";
                            };
                        } | {
                            type: "QS";
                            queryName: string;
                            match: {
                                rhs: string;
                                op: "=" | "~" | "//" | "!=" | "!~" | "!//";
                                cs?: boolean;
                            } | {
                                op: "*" | "!*";
                            };
                        } | {
                            type: "QK";
                            key: string;
                            match: {
                                rhs: string;
                                op: "=" | "~" | "//" | "!=" | "!~" | "!//";
                                cs?: boolean;
                            } | {
                                op: "*" | "!*";
                            };
                        } | {
                            type: "EVT";
                            event: {
                                rhs: string;
                                op: "=" | "~" | "//" | "!=" | "!~" | "!//";
                                cs?: boolean;
                            } | {
                                op: "*" | "!*";
                            };
                        } | {
                            type: "PV";
                            path: {
                                rhs: string;
                                op: "=" | "~" | "//" | "!=" | "!~" | "!//";
                                cs?: boolean;
                            } | {
                                op: "*" | "!*";
                            };
                        } | {
                            type: "PVC";
                            match: {
                                rhs: number;
                                op: "=" | "<" | ">" | "!=";
                            };
                        }))[];
                    };
                    conversion?: {
                        freq: "O";
                    } | null;
                };
            };
            enr?: {
                [key: string]: {
                    cap: number;
                };
            };
            agg?: {
                [key: string]: {
                    inputs: {
                        dim: string;
                        sign?: "+" | "-" | "c";
                    }[];
                };
            };
            control?: number;
        };
        test?: {
            [key: string]: {
                wv?: string;
            };
        };
    };
}>;

type GetProjectMapClientOptions = {
    cache: NonNullable<UniformServerConfig['projectMapCache']>;
};
declare const getProjectMapClient: (options: GetProjectMapClientOptions) => ProjectMapClient;
declare const getDefaultProjectMapClient: (options: Pick<CompositionContext, "searchParams">) => Promise<ProjectMapClient>;

type GetRouteClientOptions = {
    cache: NonNullable<UniformServerConfig['canvasCache']>;
};
declare const getRouteClient: (options: GetRouteClientOptions) => RouteClient;
declare const getDefaultRouteClient: (options: Pick<CompositionContext, "searchParams">) => Promise<RouteClient>;

type ContextUpdateTransferProps = {
    update: Partial<AppDirectoryContextState> | (() => Promise<Partial<ContextState> | undefined>);
    serverContext: AppDirectoryServerContext | undefined;
};
declare const ContextUpdateTransfer: React.FC<ContextUpdateTransferProps>;

type CreateStaticParamsOptions = {
    expand?: (node: ProjectMapNode) => Promise<string[] | undefined> | string[] | undefined;
};
declare const createStaticParams: (options?: CreateStaticParamsOptions) => Promise<{
    path: string[];
}[]>;
declare function generateStaticParams(): Promise<{
    path: string[];
}[]>;

type UniformContextProps = {
    /**
     * Component to initialize Uniform context on the client.
     */
    clientContextComponent?: ClientContextComponent;
};
declare const UniformContext: React.FC<PropsWithChildren<UniformContextProps>>;

type UniformPlaygroundProps = PlaygroundParameters & Omit<UniformCompositionProps, 'params' | 'searchParams' | 'route' | 'mode'>;
declare const UniformPlayground: React.FC<UniformPlaygroundProps>;

type CreateServerUniformContextProps = Omit<ContextOptions, 'transitionStore' | 'manifest'> & {
    searchParams: AwaitedPageParameters['searchParams'];
};
declare const createServerUniformContext: (options: CreateServerUniformContextProps) => Promise<AppDirectoryServerContext>;

declare const isDraftModeEnabled: ({ searchParams, }: {
    searchParams: AwaitedPageParameters["searchParams"];
}) => Promise<boolean>;
declare const isIncontextEditingEnabled: ({ searchParams, }: {
    searchParams: {
        [key: string]: string | undefined;
    } | undefined;
}) => boolean;
declare const isOnVercelPreviewEnvironment: () => boolean;
declare const isDevelopmentEnvironment: () => boolean;

type RetrieveCommonOptions = {
    /**
     * If true, the manifest will not be prefetched.
     *
     * Prefetching allows the manifest to begin loading while the route data is being retrieved.
     */
    skipPrefetch?: boolean;
};
type RetrieveRouteOptions = PageParameters & RetrieveCommonOptions;
type RetrieveSlugOptions = Pick<CompositionGetBySlugParameters, 'slug' | 'locale' | 'releaseId' | 'versionId'> & {
    /**
     * The searchParams object from Next.js router. Used for signal evaluation.
     */
    searchParams?: {
        [key: string]: string | undefined;
    };
} & RetrieveCommonOptions;
type RetrieveRouteFetchOptions = Omit<RouteGetParameters, 'projectId' | 'path' | 'withComponentIDs' | 'withContentSourceMap' | 'state'>;
declare const retrieveCompositionBySlug: ({ slug, searchParams, skipPrefetch, locale, releaseId, versionId, }: RetrieveSlugOptions) => Promise<ResolvedRouteGetResponse>;
declare const retrieveRoute: ({ params, searchParams: providedSearchParams, skipPrefetch }: RetrieveRouteOptions, fetchOptions?: RetrieveRouteFetchOptions) => Promise<ResolvedRouteGetResponse>;

export { ContextUpdateTransfer, type ContextUpdateTransferProps, type CreateServerUniformContextProps, type CreateStaticParamsOptions, type GetCanvasClientOptions, type GetManifestClientOptions, type GetProjectMapClientOptions, type GetRouteClientOptions, UniformCompositionProps, UniformContext, type UniformContextProps, UniformPlayground, type UniformPlaygroundProps, createServerUniformContext, createStaticParams, generateStaticParams, getCanvasClient, getDefaultCanvasClient, getDefaultManifestClient, getDefaultProjectMapClient, getDefaultRouteClient, getManifest, getManifestClient, getProjectMapClient, getRouteClient, isDevelopmentEnvironment, isDraftModeEnabled, isIncontextEditingEnabled, isOnVercelPreviewEnvironment, retrieveCompositionBySlug, retrieveRoute };