@builder.io/sdk-react-nextjs 0.7.1-3 → 0.7.1-4

package/lib/browser/index.d.cts

@@ -0,0 +1,1066 @@
+/// <reference types="node" resolution-mode="require"/>
+declare module "index-helpers/top-of-file" {
+    export default undefined;
+}
+declare module "index-helpers/blocks-exports" {
+    export { default as Button } from '../blocks/button/button';
+    export { default as Columns } from '../blocks/columns/columns';
+    export { default as Fragment } from '../blocks/fragment/fragment';
+    export { default as Image } from '../blocks/image/image';
+    export { default as Section } from '../blocks/section/section';
+    export { default as Symbol } from '../blocks/symbol/symbol';
+    export { default as Text } from '../blocks/text/text';
+    export { default as Video } from '../blocks/video/video';
+    import { default as Blocks } from '../components/blocks/blocks';
+    import { default as Content } from '../components/content-variants/content-variants';
+    export { Blocks, Content };
+    /**
+     * @deprecated Renamed to `Blocks`.
+     */
+    export const RenderBlocks: any;
+    /**
+     * @deprecated Renamed to `Content`.
+     */
+    export const RenderContent: any;
+}
+declare module "constants/target" {
+    /** This file should be overriden for each framework. Ideally this would be implemented in Mitosis.  */
+    export const TARGET: any;
+}
+declare module "functions/is-browser" {
+    export function isBrowser(): boolean;
+}
+declare module "functions/is-iframe" {
+    export function isIframe(): boolean;
+}
+declare module "functions/is-editing" {
+    export function isEditing(): boolean;
+}
+declare module "functions/is-previewing" {
+    export function isPreviewing(): boolean;
+}
+declare module "types/builder-block" {
+    type JSONValue = string | number | boolean | JSONObject | JSONArray;
+    interface JSONObject {
+        [x: string]: JSONValue;
+    }
+    interface JSONArray extends Array<JSONValue> {
+    }
+    /** @todo typedoc this */
+    export interface BuilderBlock {
+        '@type': '@builder.io/sdk:Element';
+        '@version'?: number;
+        id?: string;
+        tagName?: string;
+        layerName?: string;
+        groupLocked?: boolean;
+        layerLocked?: boolean;
+        /** @todo make alias for properties.class */
+        class?: string;
+        children?: BuilderBlock[];
+        responsiveStyles?: {
+            large?: Partial<CSSStyleDeclaration>;
+            medium?: Partial<CSSStyleDeclaration>;
+            small?: Partial<CSSStyleDeclaration>;
+            /** @deprecated */
+            xsmall?: Partial<CSSStyleDeclaration>;
+        };
+        component?: {
+            name: string;
+            options?: any;
+            tag?: string;
+        };
+        bindings?: {
+            [key: string]: string;
+        };
+        meta?: {
+            [key: string]: JSONValue;
+        };
+        actions?: {
+            [key: string]: string;
+        };
+        properties?: {
+            [key: string]: string;
+        };
+        code?: {
+            bindings?: {
+                [key: string]: string;
+            };
+            actions?: {
+                [key: string]: string;
+            };
+        };
+        repeat?: {
+            collection: string;
+            itemName?: string;
+        } | null;
+        animations?: any[];
+        style?: Partial<CSSStyleDeclaration>;
+        /**
+         * generated by the "Hide If" binding
+         */
+        hide?: boolean;
+        /**
+         * generated by the "Show If" binding
+         */
+        show?: boolean;
+    }
+}
+declare module "types/input" {
+    export interface Input {
+        /** This is the name of the component prop this input represents */
+        name: string;
+        /** A friendlier name to show in the UI if the component prop name is not ideal for end users */
+        friendlyName?: string;
+        /** @hidden @deprecated */
+        description?: string;
+        /** A default value to use */
+        defaultValue?: any;
+        /**
+         * The type of input to use, such as 'text'
+         *
+         * See all available inputs [here](https://www.builder.io/c/docs/custom-react-components#input-types)
+         * and you can create your own custom input types and associated editor UIs with [plugins](https://www.builder.io/c/docs/extending/plugins)
+         */
+        type: string;
+        /** Is this input mandatory or not */
+        required?: boolean;
+        /** @hidden */
+        autoFocus?: boolean;
+        subFields?: Input[];
+        /**
+         * Additional text to render in the UI to give guidance on how to use this
+         *
+         * @example
+         * ```js
+         * helperText: 'Be sure to use a proper URL, starting with "https://"'
+         * 111
+         */
+        helperText?: string;
+        /** @hidden */
+        allowedFileTypes?: string[];
+        /** @hidden */
+        imageHeight?: number;
+        /** @hidden */
+        imageWidth?: number;
+        /** @hidden */
+        mediaHeight?: number;
+        /** @hidden */
+        mediaWidth?: number;
+        /** @hidden */
+        hideFromUI?: boolean;
+        /** @hidden */
+        modelId?: string;
+        /**
+         * Number field type validation maximum accepted input
+         */
+        max?: number;
+        /**
+         * Number field type validation minimum accepted input
+         */
+        min?: number;
+        /**
+         * Number field type step size when using arrows
+         */
+        step?: number;
+        /**
+         * Set this to `true` to show the editor for this input when
+         * children of this component are selected. This is useful for things
+         * like Tabs, such that users may not always select the Tabs component
+         * directly but will still be looking for how to add additional tabs
+         */
+        broadcast?: boolean;
+        /**
+         * Set this to `true` to show the editor for this input when
+         * group locked parents of this component are selected. This is useful
+         * to bubble up important inputs for locked groups, like text and images
+         */
+        bubble?: boolean;
+        /**
+         * Set this to `true` if you want this component to be translatable
+         */
+        localized?: boolean;
+        /** @hidden */
+        options?: {
+            [key: string]: any;
+        };
+        /**
+         * For "text" input type, specifying an enum will show a dropdown of options instead
+         */
+        enum?: string[] | {
+            label: string;
+            value: any;
+            helperText?: string;
+        }[];
+        /** Regex field validation for all string types (text, longText, html, url, etc) */
+        regex?: {
+            /** pattern to test, like "^\/[a-z]$" */
+            pattern: string;
+            /** flags for the RegExp constructor, e.g. "gi"  */
+            options?: string;
+            /**
+             * Friendly message to display to end-users if the regex fails, e.g.
+             * "You must use a relative url starting with '/...' "
+             */
+            message: string;
+        };
+        /**
+         * Set this to `true` to put this under the "show more" section of
+         * the options editor. Useful for things that are more advanced
+         * or more rarely used and don't need to be too prominent
+         */
+        advanced?: boolean;
+        /** @hidden */
+        /** @hidden */
+        code?: boolean;
+        /** @hidden */
+        richText?: boolean;
+        /** @hidden */
+        showIf?: ((options: Map<string, any>) => boolean) | string;
+        /** @hidden */
+        copyOnAdd?: boolean;
+        /**
+         * Use optionally with inputs of type `reference`. Restricts the content entry picker to a specific model by name.
+         */
+        model?: string;
+        valueType?: {
+            type?: string;
+        };
+        onChange?: ((options: Map<string, any>) => void | Promise<void>) | string;
+    }
+}
+declare module "types/typescript" {
+    export type Nullable<T> = T | null | undefined;
+    export type Dictionary<T> = {
+        [key: string]: T;
+    };
+    export type Overwrite<T, U> = keyof U extends keyof T ? Pick<T, Exclude<keyof T, keyof U>> & U : never;
+    export type Prettify<T> = {
+        [K in keyof T]: T[K];
+    } & {};
+    export type PropsWithChildren<P> = P & {
+        children?: any;
+    };
+}
+declare module "types/builder-content" {
+    import type { BuilderBlock } from "types/builder-block";
+    import type { Input } from "types/input";
+    import type { Nullable } from "types/typescript";
+    export interface Breakpoints {
+        small: number;
+        medium: number;
+    }
+    export interface BuilderContentVariation {
+        data?: {
+            title?: string;
+            blocks?: BuilderBlock[];
+            inputs?: Input[];
+            state?: {
+                [key: string]: any;
+            };
+            jsCode?: string;
+            tsCode?: string;
+            httpRequests?: {
+                [key: string]: string;
+            };
+            [key: string]: any;
+        };
+        name?: string;
+        testRatio?: number;
+        id?: string;
+        meta?: {
+            breakpoints?: Nullable<Breakpoints>;
+            [key: string]: any;
+        };
+    }
+    export interface BuilderContent extends BuilderContentVariation {
+        '@version'?: number;
+        published?: 'published' | 'draft' | 'archived';
+        modelId?: string;
+        priority?: number;
+        lastUpdated?: number;
+        startDate?: number;
+        endDate?: number;
+        variations?: {
+            [id: string]: BuilderContentVariation;
+        };
+        testVariationId?: string;
+        testVariationName?: string;
+    }
+}
+declare module "types/element" {
+    type JSONValue = string | number | boolean | JSONObject | JSONArray;
+    interface JSONObject {
+        [x: string]: JSONValue;
+    }
+    interface JSONArray extends Array<JSONValue> {
+    }
+    /** @todo typedoc this */
+    export interface BuilderElement {
+        '@type': '@builder.io/sdk:Element';
+        '@version'?: number;
+        id?: string;
+        tagName?: string;
+        layerName?: string;
+        groupLocked?: boolean;
+        layerLocked?: boolean;
+        /** @todo make alias for properties.class */
+        class?: string;
+        children?: BuilderElement[];
+        responsiveStyles?: {
+            large?: Partial<CSSStyleDeclaration>;
+            medium?: Partial<CSSStyleDeclaration>;
+            small?: Partial<CSSStyleDeclaration>;
+            /** @deprecated */
+            xsmall?: Partial<CSSStyleDeclaration>;
+        };
+        component?: {
+            name: string;
+            options?: any;
+            tag?: string;
+        };
+        bindings?: {
+            [key: string]: string;
+        };
+        meta?: {
+            [key: string]: JSONValue;
+        };
+        actions?: {
+            [key: string]: string;
+        };
+        properties?: {
+            [key: string]: string;
+        };
+        code?: {
+            bindings?: {
+                [key: string]: string;
+            };
+            actions?: {
+                [key: string]: string;
+            };
+        };
+        repeat?: {
+            collection: string;
+            itemName?: string;
+        } | null;
+        animations?: Animation[];
+    }
+    interface Animation {
+    }
+}
+declare module "types/components" {
+    import type { BuilderElement } from "types/element";
+    import type { Input } from "types/input";
+    export interface ComponentInfo {
+        /**
+         * Name your component something unique, e.g. 'MyButton'. You can override built-in components
+         * by registering a component with the same name, e.g. 'Text', to replace the built-in text component
+         */
+        name: string;
+        description?: string;
+        /**
+         * Link to a documentation page for this component
+         */
+        docsLink?: string;
+        image?: string;
+        /**
+         * Input schema for your component for users to fill in the options
+         */
+        inputs?: Input[];
+        class?: any;
+        type?: 'angular' | 'webcomponent' | 'react' | 'vue';
+        defaultStyles?: {
+            [key: string]: string;
+        };
+        /**
+         * Turn on if your component can accept children. Be sure to use in combination with
+         * withChildren(YourComponent) like here
+         * github.com/BuilderIO/builder/blob/master/examples/react-design-system/src/components/HeroWithChildren/HeroWithChildren.builder.js#L5
+         */
+        canHaveChildren?: boolean;
+        fragment?: boolean;
+        /**
+         * Do not wrap a component in a dom element. Be sure to use {...props.attributes} with this option
+         * like here github.com/BuilderIO/builder/blob/master/packages/react/src/blocks/forms/Input.tsx#L34
+         */
+        noWrap?: boolean;
+        /**
+         * TO-DO: make this optional only for RSC SDK.
+         *
+         * Set this to `true` if your component is a React Server Component (RSC).
+         */
+        isRSC?: boolean;
+        /**
+         * Default children
+         */
+        defaultChildren?: BuilderElement[];
+        defaults?: Partial<BuilderElement>;
+        hooks?: {
+            [key: string]: string | Function;
+        };
+        /**
+         * Hide your component in editor, useful for gradually deprecating components
+         */
+        hideFromInsertMenu?: boolean;
+        tag?: string;
+        static?: boolean;
+        /**
+         * Passing a list of model names will restrict using the component to only the models listed here, otherwise it'll be available for all models
+         */
+        models?: string[];
+        /**
+         * Specify restrictions direct children must match
+         */
+        childRequirements?: {
+            /** Message to show when this doesn't match, e.g. "Children of 'Columns' must be a 'Column'" */
+            message: string;
+            /** Simple way to say children must be a specific component name */
+            component?: string;
+            /**
+             * More advanced - specify a MongoDB-style query (using sift.js github.com/crcn/sift.js)
+             * of what the children objects should match, e.g.
+             *
+             * @example
+             *  query: {
+             *    // Child of this element must be a 'Button' or 'Text' component
+             *    'component.name': { $in: ['Button', 'Text'] }
+             *  }
+             */
+            query?: any;
+        };
+        /**
+         * Specify restrictions any parent must match
+         */
+        requiresParent?: {
+            /** Message to show when this doesn't match, e.g. "'Add to cart' buttons must be within a 'Product box'" */
+            message: string;
+            /** Simple way to say a parent must be a specific component name, e.g. 'Product box' */
+            component?: string;
+            /**
+             * More advanced - specify a MongoDB-style query (using sift.js github.com/crcn/sift.js)
+             * of what at least one parent in the parents hierarchy should match, e.g.
+             *
+             * @example
+             *  query: {
+             *    // Thils element must be somewhere inside either a 'Product box' or 'Collection' component
+             *    'component.name': { $in: ['Product Box', 'Collection'] }
+             *  }
+             */
+            query?: any;
+        };
+        friendlyName?: string;
+        /**
+         * Use to restrict access to your component based on a the current user permissions
+         * By default components will show to all users
+         * for more information on permissions in builder check https://www.builder.io/c/docs/guides/roles-and-permissions
+         */
+        requiredPermissions?: Array<Permission>;
+        hidden?: boolean;
+    }
+    type Permission = 'read' | 'publish' | 'editCode' | 'editDesigns' | 'admin' | 'create';
+}
+declare module "types/api-version" {
+    export type ApiVersion = 'v2' | 'v3';
+    export const DEFAULT_API_VERSION: ApiVersion;
+}
+declare module "context/types" {
+    import type { BuilderContent } from "types/builder-content";
+    import type { ComponentInfo } from "types/components";
+    import type { Dictionary, Nullable } from "types/typescript";
+    import type { ApiVersion } from "types/api-version";
+    export type RegisteredComponent = ComponentInfo & {
+        component: any;
+    };
+    export type RegisteredComponents = Dictionary<RegisteredComponent>;
+    export type BuilderRenderState = Record<string, unknown>;
+    export type BuilderRenderContext = Record<string, unknown>;
+    export interface BuilderContextInterface {
+        content: Nullable<BuilderContent>;
+        context: BuilderRenderContext;
+        /**
+         * The state of the application.
+         *
+         * NOTE: see `localState` below to understand how it is different from `rootState`.
+         */
+        rootState: BuilderRenderState;
+        /**
+         * Some frameworks have a `setState` function which needs to be invoked to notify
+         * the framework of state change. (other frameworks don't in which case it is `undefined')
+         */
+        rootSetState: ((rootState: BuilderRenderState) => void) | undefined;
+        /**
+         * The local state of the current component. This is different from `rootState` in that
+         * it can be a child state created by a repeater containing local state.
+         * The `rootState` is where all of the state mutations are actually stored.
+         */
+        localState: BuilderRenderState | undefined;
+        apiKey: string | null;
+        apiVersion: ApiVersion | undefined;
+        componentInfos: Dictionary<ComponentInfo>;
+        inheritedStyles: Record<string, unknown>;
+    }
+}
+declare module "functions/fast-clone" {
+    /**
+     * We need to serialize values to a string in case there are Proxy values, as is the case with SolidJS etc.
+     */
+    export const fastClone: <T extends object>(obj: T) => T;
+}
+declare module "functions/register-component" {
+    import type { RegisteredComponent } from "context/types";
+    import type { ComponentInfo } from "types/components";
+    /**
+     * @deprecated.  Use the `customComponents` prop in RenderContent instead to provide your custom components to the builder SDK.
+     */
+    export const components: RegisteredComponent[];
+    /**
+     * @deprecated.  Use the `customComponents` prop in RenderContent instead to provide your custom components to the builder SDK.
+     */
+    export function registerComponent(component: any, info: ComponentInfo): void;
+    export const createRegisterComponentMessage: (info: ComponentInfo) => {
+        type: string;
+        data: ComponentInfo;
+    };
+    export const serializeComponentInfo: ({ inputs, ...info }: ComponentInfo) => ComponentInfo;
+}
+declare module "types/deep-partial" {
+    export type DeepPartial<T> = {
+        [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : DeepPartial<T[P]>;
+    };
+}
+declare module "functions/register" {
+    import type { BuilderBlock } from "types/builder-block";
+    import type { DeepPartial } from "types/deep-partial";
+    export interface InsertMenuItem {
+        name: string;
+        icon?: string;
+        item: DeepPartial<BuilderBlock>;
+    }
+    export interface InsertMenuConfig {
+        name: string;
+        priority?: number;
+        persist?: boolean;
+        advanced?: boolean;
+        items: InsertMenuItem[];
+    }
+    export function register(type: 'insertMenu', info: InsertMenuConfig): void;
+    export function register(type: string, info: any): void;
+}
+declare module "functions/set-editor-settings" {
+    export type Settings = {
+        customInsertMenu?: boolean;
+    };
+    export function setEditorSettings(newSettings: Settings): void;
+}
+declare module "types/can-track" {
+    export type CanTrack = {
+        canTrack: boolean;
+    };
+}
+declare module "helpers/logger" {
+    export const logger: {
+        log: (...message: any[]) => void;
+        error: (...message: any[]) => void;
+        warn: (...message: any[]) => void;
+        debug: (...message: any[]) => void;
+    };
+}
+declare module "helpers/nullable" {
+    export type Nullable<T> = T | null | undefined;
+    export const checkIsDefined: <T>(maybeT: T) => maybeT is T;
+}
+declare module "helpers/url" {
+    /**
+     * Only gets one level up from hostname
+     * wwww.example.com -> example.com
+     * www.example.co.uk -> example.co.uk
+     */
+    export const getTopLevelDomain: (host: string) => string;
+}
+declare module "helpers/cookie" {
+    import type { CanTrack } from "types/can-track";
+    type GetCookieArgs = {
+        name: string;
+    } & CanTrack;
+    export const getCookieSync: ({ name, canTrack }: GetCookieArgs) => string | undefined;
+    /**
+     * NOTE: This function is `async` because its react-native override is async. Do not remove the `async` keyword!
+     * The sync version is only safe to use in code blocks that `react-native` is guaranteed not to not run.
+     */
+    export const getCookie: (args: GetCookieArgs) => Promise<string>;
+    /**
+     * NOTE: This function is `async` because its react-native override is async. Do not remove the `async` keyword!
+     */
+    export const setCookie: ({ name, value, expires, canTrack }: {
+        name: string;
+        value: string;
+        expires?: Date;
+    } & CanTrack) => Promise<void>;
+}
+declare module "helpers/ab-tests" {
+    import type { CanTrack } from "types/can-track";
+    import type { BuilderContent } from "types/builder-content";
+    import type { Nullable } from "types/typescript";
+    export const handleABTestingSync: ({ item, canTrack }: {
+        item: Nullable<BuilderContent>;
+    } & CanTrack) => Nullable<BuilderContent>;
+    export const handleABTesting: ({ item, canTrack }: {
+        item: BuilderContent;
+    } & CanTrack) => Promise<BuilderContent>;
+}
+declare module "helpers/canTrack" {
+    export const getDefaultCanTrack: (canTrack?: boolean) => boolean;
+}
+declare module "helpers/preview-lru-cache/get" {
+    export function getPreviewContent(searchParams: URLSearchParams): any;
+}
+declare module "functions/get-global-this" {
+    type Global = typeof global | typeof window | typeof self | typeof globalThis;
+    export function getGlobalThis(): Global;
+}
+declare module "functions/get-fetch" {
+    export const fetch: typeof globalThis.fetch;
+}
+declare module "helpers/flatten" {
+    /**
+     * Convert deep object to a flat object with dots
+     *
+     * { foo: { bar: 'baz' }} -> { 'foo.bar': 'baz' }
+     */
+    export function flatten<T extends Record<string, any>>(object: T, path?: string | null, separator?: string): T;
+}
+declare module "functions/get-builder-search-params/index" {
+    type QueryObject = Record<string, string | string[]>;
+    export const convertSearchParamsToQueryObject: (searchParams: URLSearchParams) => QueryObject;
+    /**
+     * Receives a `URLSearchParams` object or a regular query object, and returns the subset of query params that are
+     * relevant to the Builder SDK.
+     *
+     * @returns
+     */
+    export const getBuilderSearchParams: (_options: QueryObject | URLSearchParams | undefined) => QueryObject;
+    export const getBuilderSearchParamsFromWindow: () => QueryObject;
+    export const normalizeSearchParams: (searchParams: QueryObject | URLSearchParams) => QueryObject;
+}
+declare module "functions/get-content/types" {
+    export interface GetContentOptions {
+        /** The model to get content for */
+        model: string;
+        /** Your public API key */
+        apiKey: string;
+        /** Number of items to fetch. Default is 1 */
+        limit?: number;
+        /**
+         * Use to specify an offset for pagination of results. The default is 0.
+         */
+        offset?: number;
+        /**
+         * User attribute key value pairs to be used for targeting
+         * https://www.builder.io/c/docs/custom-targeting-attributes
+         *
+         * e.g.
+         * ```js
+         * userAttributes: {
+         *   urlPath: '/',
+         *   returnVisitor: true,
+         *   device: 'mobile'
+         * }
+         * ```
+         */
+        userAttributes?: (Record<string, string> & {
+            urlPath?: string;
+        }) | null;
+        /**
+         * Mongodb style query of your data. E.g.:
+         *
+         * ```js
+         * query: {
+         *  id: 'abc123',
+         *  data: {
+         *    myCustomField: { $gt: 20 },
+         *  }
+         * }
+         * ```
+         *
+         * See more info on MongoDB's query operators and format.
+         *
+         * @see {@link https://docs.mongodb.com/manual/reference/operator/query/}
+         */
+        query?: Record<string, any>;
+        /**
+         * Any other API options.
+         * Accepts both a key/value object or a `URLSearchParams` instance
+         * */
+        options?: Record<string, any> | URLSearchParams;
+        /**
+         * If set to `true`, it will lazy load symbols/references.
+         * If set to `false`, it will render the entire content tree eagerly.
+         * @deprecated use `enrich` instead
+         */
+        noTraverse?: boolean;
+        /**
+         * If set to `false`, it will not use cookies to target content. Therefore, A/B Testing will be disabled and
+         * only the default variation will be returned to every user.
+         *
+         * Defaults to `true`.
+         */
+        canTrack?: boolean;
+        /**
+         * Include content of references in the response. Defaults to `true`.
+         * @deprecated use `enrich` instead
+         */
+        includeRefs?: boolean;
+        /**
+         * Include multilevel references in the response.
+         */
+        enrich?: boolean;
+        /**
+         * If provided, the API will auto-resolve localized objects to the value of this `locale` key.
+         */
+        locale?: string;
+        /**
+         * If provided, sets the Builder API version used to fetch content.
+         *
+         * Defaults to `v3`.
+         */
+        apiVersion?: 'v2' | 'v3';
+        /**
+         * Only include these fields.
+         * Note: 'omit' takes precedence over 'fields'
+         *
+         * @example
+         * ```
+         * fields: 'id, name, data.customField'
+         * ```
+         */
+        fields?: string;
+        /**
+         * Omit only these fields.
+         * Note: 'omit' takes precedence over 'fields'
+         *
+         * @example
+         * ```
+         * omit: 'data.bigField,data.blocks'
+         * ```
+         */
+        omit?: string;
+        /**
+         * Seconds to cache content. Sets the max-age of the cache-control header
+         * response header.
+         *
+         * Use a higher value for better performance, lower for content that will change more frequently
+         *
+         * @see {@link https://www.builder.io/c/docs/query-api#__next:~:text=%26includeRefs%3Dtrue-,cacheSeconds,-No}
+         */
+        cacheSeconds?: number;
+        /**
+         * Builder.io uses stale-while-revalidate caching at the CDN level. This means we always serve
+         * from edge cache and update caches in the background for maximum possible performance. This also
+         * means that the more frequently content is requested, the more fresh it will be. The longest we
+         * will ever hold something in stale cache is 1 day by default, and you can set this to be shorter
+         * yourself as well. We suggest keeping this high unless you have content that must change rapidly
+         * and gets very little traffic.
+         *
+         * @see {@link https://www.fastly.com/blog/prevent-application-network-instability-serve-stale-content}
+         */
+        staleCacheSeconds?: number;
+        /**
+         * Property to order results by.
+         * Use 1 for ascending and -1 for descending.
+         *
+         * The key is what you're sorting on, so the following example sorts by createdDate
+         * and because the value is 1, the sort is ascending.
+         *
+         * @example
+         * ```
+         * createdDate: 1
+         * ```
+         */
+        sort?: {
+            [key: string]: 1 | -1;
+        };
+        /**
+         * Include content entries in a response that are still in
+         * draft mode and un-archived. Default is false.
+         */
+        includeUnpublished?: boolean;
+    }
+}
+declare module "functions/get-content/generate-content-url" {
+    import type { GetContentOptions } from "functions/get-content/types";
+    export const generateContentUrl: (options: GetContentOptions) => URL;
+}
+declare module "functions/get-content/index" {
+    import type { BuilderContent } from "types/builder-content";
+    import type { GetContentOptions } from "functions/get-content/types";
+    /**
+     * Returns a the first entry that matches the given options.
+     */
+    export function fetchOneEntry(options: GetContentOptions): Promise<BuilderContent | null>;
+    /**
+     * @deprecated `getContent` was renamed to `fetchOneEntry`. This is a temporary alias to avoid breaking changes.
+     *
+     * NOTE: consider using `fetchBuilderProps` instead for easier setup.
+     */
+    export const getContent: typeof fetchOneEntry;
+    type ContentResults = {
+        results: BuilderContent[];
+    };
+    /**
+     * @internal Exported only for testing purposes. Do not use.
+     */
+    export const _processContentResult: (options: GetContentOptions, content: ContentResults, url?: URL) => Promise<ContentResults>;
+    /**
+     * Returns a paginated array of entries that match the given options.
+     */
+    export function fetchEntries(options: GetContentOptions): Promise<ContentResults>;
+    /**
+     * @deprecated `getAllContent` was renamed to `fetchEntries`. This is a temporary alias to avoid breaking changes.
+     */
+    export const getAllContent: typeof fetchEntries;
+}
+declare module "helpers/uuid" {
+    /**
+     * @credit https://stackoverflow.com/a/2117523
+     */
+    export function uuidv4(): string;
+    /**
+     * Slightly cleaner and smaller UUIDs
+     */
+    export function uuid(): string;
+}
+declare module "helpers/sessionId" {
+    import type { CanTrack } from "types/can-track";
+    export const getSessionId: ({ canTrack }: CanTrack) => Promise<string | undefined>;
+    export const createSessionId: () => string;
+    export const setSessionId: ({ id, canTrack }: {
+        id: string;
+    } & CanTrack) => Promise<void>;
+}
+declare module "helpers/localStorage" {
+    import type { CanTrack } from "types/can-track";
+    import type { Nullable } from "helpers/nullable";
+    export const getLocalStorageItem: ({ key, canTrack }: {
+        key: string;
+    } & CanTrack) => Nullable<string>;
+    export const setLocalStorageItem: ({ key, canTrack, value }: {
+        key: string;
+        value: string;
+    } & CanTrack) => void;
+}
+declare module "helpers/visitorId" {
+    import type { CanTrack } from "types/can-track";
+    export const getVisitorId: ({ canTrack }: CanTrack) => string | undefined;
+    export const createVisitorId: () => string;
+    export const setVisitorId: ({ id, canTrack }: {
+        id: string;
+    } & CanTrack) => void;
+}
+declare module "functions/track/helpers" {
+    export const getUserAttributes: () => {
+        urlPath: string;
+        host: string;
+        device: string;
+    };
+}
+declare module "functions/track/index" {
+    import type { CanTrack } from "types/can-track";
+    import type { Dictionary } from "types/typescript";
+    interface Event {
+        /**
+         * The type of your event.
+         *
+         * Examples: `click`, `conversion`, `pageview`, `impression`
+         */
+        type: string;
+        data: {
+            /**
+             * (Optional) The content's ID. Useful if this event pertains to a specific piece of content.
+             */
+            contentId?: string;
+            /**
+             * This is the ID of the space that the content belongs to.
+             */
+            ownerId: string;
+            /**
+             * (Optional) metadata that you want to provide with your event.
+             */
+            metadata?: Dictionary<any>;
+            /**
+             * Session ID of the user. This is provided by the SDK by checking session storage.
+             */
+            sessionId: string | undefined;
+            /**
+             * Visitor ID of the user. This is provided by the SDK by checking cookies.
+             */
+            visitorId: string | undefined;
+            /**
+             * (Optional) If running an A/B test, the ID of the variation that the user is in.
+             */
+            variationId?: string;
+            [index: string]: any;
+        };
+    }
+    type EventProperties = Pick<Event, 'type'> & Pick<Event['data'], 'contentId' | 'variationId' | 'metadata'> & {
+        /**
+         * Your organization's API key.
+         */
+        apiKey: Event['data']['ownerId'];
+        /**
+         * (Optional) Any additional (non-metadata) properties to add to the event.
+         */
+        [index: string]: any;
+    };
+    export type EventProps = EventProperties & CanTrack;
+    export function _track(eventProps: EventProps): Promise<void | Response>;
+    export const track: (args: EventProperties) => Promise<void | Response>;
+}
+declare module "types/enforced-partials" {
+    import type { Prettify } from "types/typescript";
+    type OptionalFieldsOnly<T> = {
+        [K in keyof T as T[K] extends Required<T>[K] ? never : K]: T[K];
+    };
+    type RequiredFieldsOnly<T> = {
+        [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];
+    };
+    type Enforced<T> = {
+        [K in keyof T]-?: T[K];
+    };
+    type AndUndefined<T> = {
+        [K in keyof T]: T[K] | undefined;
+    };
+    /**
+     * Enforce that all optional fields are undefined
+     * @example
+     * type Foo = { a: string, b?: number }
+     * type Bar = EnforcePartials<Foo> // { a: string, b: number | undefined }
+     */
+    export type EnforcePartials<From> = Prettify<AndUndefined<Enforced<OptionalFieldsOnly<From>>> & RequiredFieldsOnly<From>>;
+}
+declare module "components/content-variants/content-variants.types" {
+    import type { BuilderRenderContext, RegisteredComponent } from "context/types";
+    import type { ApiVersion } from "types/api-version";
+    import type { BuilderContent } from "types/builder-content";
+    import type { Nullable } from "types/typescript";
+    export interface ContentVariantsPrps {
+        content?: Nullable<BuilderContent>;
+        model?: string;
+        data?: {
+            [key: string]: any;
+        };
+        context?: BuilderRenderContext;
+        apiKey: string;
+        apiVersion?: ApiVersion;
+        customComponents?: RegisteredComponent[];
+        canTrack?: boolean;
+        locale?: string;
+        /** @deprecated use `enrich` instead **/
+        includeRefs?: boolean;
+        enrich?: boolean;
+    }
+}
+declare module "components/content/content.types" {
+    import type { BuilderRenderState } from "context/types";
+    import type { EnforcePartials } from "types/enforced-partials";
+    import type { ContentVariantsPrps } from "components/content-variants/content-variants.types";
+    interface InternalRenderProps {
+        /**
+         * TO-DO: improve qwik generator to not remap this name for non-HTML tags, then name it `className`
+         */
+        classNameProp: string | undefined;
+        showContent: boolean;
+        isSsrAbTest: boolean;
+    }
+    export type ContentProps = InternalRenderProps & EnforcePartials<ContentVariantsPrps>;
+    export interface BuilderComponentStateChange {
+        state: BuilderRenderState;
+        ref: {
+            name?: string;
+            props?: {
+                builderBlock?: {
+                    id?: string;
+                };
+            };
+        };
+    }
+}
+declare module "functions/fetch-builder-props" {
+    import type { ContentVariantsPrps } from "components/content-variants/content-variants.types";
+    import type { Dictionary } from "types/typescript";
+    import type { GetContentOptions } from "functions/get-content/types";
+    type GetBuilderPropsOptions = (Omit<GetContentOptions, 'model'> & {
+        model?: string;
+    }) & ({
+        /**
+         * The current URL path. Used to determine the `urlPath` for targeting content.
+         *
+         * Cannot be used with `url`.
+         */
+        path: string;
+        /**
+         * The current URL search params. Used to parse the `searchParams` for targeting content.
+         *
+         * Cannot be used with `url`.
+         */
+        searchParams?: URLSearchParams | Dictionary<string | string[]>;
+        url?: undefined;
+    } | {
+        /**
+         * The current URL. Used to determine the `urlPath` for targeting content and
+         * to parse the `searchParams` for targeting content.
+         *
+         * Cannot be used with `path` or `searchParams`.
+         */
+        url: URL;
+        path?: undefined;
+        searchParams?: undefined;
+    } | {
+        url?: undefined;
+        path?: undefined;
+        searchParams?: undefined;
+    });
+    /**
+     * Given an `apiKey` and `url` (or `path` + `searchParams`), provides all props that `Content` needs to render Builder Content.
+     *
+     * @example
+     * ```jsx
+     * const builderProps = await fetchBuilderProps({
+     *    apiKey: 'API_KEY',
+     *    // provide `url`
+     *    url: yourPageUrl,
+     *    // OR provide `path` + `searchParams`
+     *    path: yourPath,
+     *    searchParams: yourSearchParams,
+     * });
+     *
+     * return <Content {...builderProps} />;
+     * ```
+     */
+    export const fetchBuilderProps: (_args: GetBuilderPropsOptions) => Promise<ContentVariantsPrps>;
+}
+declare module "server-index" {
+    export * from "index-helpers/top-of-file";
+    export { isEditing } from "functions/is-editing";
+    export { isPreviewing } from "functions/is-previewing";
+    export { createRegisterComponentMessage } from "functions/register-component";
+    export { register } from "functions/register";
+    export type { InsertMenuConfig, InsertMenuItem } from "functions/register";
+    export { setEditorSettings } from "functions/set-editor-settings";
+    export type { Settings } from "functions/set-editor-settings";
+    export { fetchEntries, fetchOneEntry, getAllContent, getContent, _processContentResult } from "functions/get-content/index";
+    export { getBuilderSearchParams } from "functions/get-builder-search-params/index";
+    export { track } from "functions/track/index";
+    export type { RegisteredComponent } from "context/types";
+    export type { ComponentInfo } from "types/components";
+    export type { ContentProps } from "components/content/content.types";
+    export { fetchBuilderProps } from "functions/fetch-builder-props";
+}
+declare module "index" {
+    export * from "index-helpers/top-of-file";
+    export * from "index-helpers/blocks-exports";
+    /**
+     * We have a separate entry point to the SDKs that guarantees no components are being imported. This is useful
+     * for React SDK, which would break in the NextJS App directory because the component imports have `use client` in them.
+     */
+    export * from "server-index";
+}