@builder.io/sdk-react 2.0.23 → 2.0.24-1

package/types/esm/components/content-variants/index.d.mts

@@ -0,0 +1 @@
+export { default } from './content-variants.js';

package/types/esm/components/content-variants/inlined-fns.d.mts

@@ -0,0 +1,14 @@
+/**
+ * WARNING: This file contains functions that get stringified and inlined into the HTML at build-time.
+ * They cannot import anything.
+ */
+/**
+ * For more information on how this works,
+ * see our [SSR A/B Test Docs](https://github.com/BuilderIO/builder/tree/main/packages/sdks/src/SSR_AB_TEST.md)
+ */
+/**
+ * For more information on how this works,
+ * see our [SSR A/B Test Docs](https://github.com/BuilderIO/builder/tree/main/packages/sdks/src/SSR_AB_TEST.md)
+ */
+export declare const UPDATE_COOKIES_AND_STYLES_SCRIPT = "function updateCookiesAndStyles(contentId, variants, isHydrationTarget) {\n  function getAndSetVariantId() {\n    function setCookie(name, value, days) {\n      let expires = '';\n      if (days) {\n        const date = new Date();\n        date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);\n        expires = '; expires=' + date.toUTCString();\n      }\n      document.cookie = name + '=' + (value || '') + expires + '; path=/' + '; Secure; SameSite=None';\n    }\n    function getCookie(name) {\n      const nameEQ = name + '=';\n      const ca = document.cookie.split(';');\n      for (let i = 0; i < ca.length; i++) {\n        let c = ca[i];\n        while (c.charAt(0) === ' ') c = c.substring(1, c.length);\n        if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length, c.length);\n      }\n      return null;\n    }\n    const cookieName = `builder.tests.${contentId}`;\n    const variantInCookie = getCookie(cookieName);\n    const availableIDs = variants.map(vr => vr.id).concat(contentId);\n    if (variantInCookie && availableIDs.includes(variantInCookie)) {\n      return variantInCookie;\n    }\n    let n = 0;\n    const random = Math.random();\n    for (let i = 0; i < variants.length; i++) {\n      const variant = variants[i];\n      const testRatio = variant.testRatio;\n      n += testRatio;\n      if (random < n) {\n        setCookie(cookieName, variant.id);\n        return variant.id;\n      }\n    }\n    setCookie(cookieName, contentId);\n    return contentId;\n  }\n  const winningVariantId = getAndSetVariantId();\n  const styleEl = document.currentScript?.previousElementSibling;\n  if (isHydrationTarget) {\n    styleEl.remove();\n    const thisScriptEl = document.currentScript;\n    thisScriptEl?.remove();\n  } else {\n    const newStyleStr = variants.concat({\n      id: contentId\n    }).filter(variant => variant.id !== winningVariantId).map(value => {\n      return `.variant-${value.id} {  display: none; }\n        `;\n    }).join('');\n    styleEl.innerHTML = newStyleStr;\n  }\n}";
+export declare const UPDATE_VARIANT_VISIBILITY_SCRIPT = "function updateVariantVisibility(variantContentId, defaultContentId, isHydrationTarget) {\n  if (!navigator.cookieEnabled) {\n    return;\n  }\n  function getCookie(name) {\n    const nameEQ = name + '=';\n    const ca = document.cookie.split(';');\n    for (let i = 0; i < ca.length; i++) {\n      let c = ca[i];\n      while (c.charAt(0) === ' ') c = c.substring(1, c.length);\n      if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length, c.length);\n    }\n    return null;\n  }\n  const cookieName = `builder.tests.${defaultContentId}`;\n  const winningVariant = getCookie(cookieName);\n  const parentDiv = document.currentScript?.parentElement;\n  const isDefaultContent = variantContentId === defaultContentId;\n  const isWinningVariant = winningVariant === variantContentId;\n  if (isWinningVariant && !isDefaultContent) {\n    parentDiv?.removeAttribute('hidden');\n    parentDiv?.removeAttribute('aria-hidden');\n  } else if (!isWinningVariant && isDefaultContent) {\n    parentDiv?.setAttribute('hidden', 'true');\n    parentDiv?.setAttribute('aria-hidden', 'true');\n  }\n  if (isHydrationTarget) {\n    if (!isWinningVariant) {\n      parentDiv?.remove();\n    }\n    const thisScriptEl = document.currentScript;\n    thisScriptEl?.remove();\n  }\n  return;\n}";

package/types/esm/components/dynamic-div.d.mts

@@ -0,0 +1,15 @@
+import * as React from "react";
+export interface DynamicDivProps {
+    children?: any;
+    attributes: any;
+    actionAttributes: any;
+    BlockWrapperProps: any;
+    builderPath: any;
+    builderParentId: any;
+    BlocksWrapperProps: any;
+    contentWrapperProps: any;
+    builderModel: any;
+    ref: any;
+}
+declare function DynamicDiv(props: DynamicDivProps): React.JSX.Element;
+export default DynamicDiv;

package/types/esm/components/dynamic-renderer/dynamic-renderer.d.mts

@@ -0,0 +1,9 @@
+import * as React from "react";
+export interface DynamicRendererProps {
+    children?: any;
+    TagName: any;
+    attributes: any;
+    actionAttributes: any;
+}
+declare function DynamicRenderer(props: DynamicRendererProps): React.JSX.Element;
+export default DynamicRenderer;

package/types/esm/components/dynamic-renderer/dynamic-renderer.helpers.d.mts

@@ -0,0 +1 @@
+export declare const isEmptyElement: (tagName: any) => boolean;

package/types/esm/components/error-boundary.d.mts

@@ -0,0 +1,11 @@
+import React from 'react';
+export default class ErrorBoundary extends React.Component<React.PropsWithChildren, {
+    hasError: boolean;
+}> {
+    constructor(props: any);
+    static getDerivedStateFromError(_error: any): {
+        hasError: boolean;
+    };
+    componentDidCatch(error: any, info: any): void;
+    render(): string | number | boolean | React.JSX.Element | Iterable<React.ReactNode>;
+}

package/types/esm/components/inlined-script.d.mts

@@ -0,0 +1,7 @@
+import * as React from "react";
+interface Props {
+    scriptStr: string;
+    id: string;
+}
+declare function InlinedScript(props: Props): React.JSX.Element;
+export default InlinedScript;

package/types/esm/components/inlined-styles.d.mts

@@ -0,0 +1,7 @@
+import * as React from "react";
+interface Props {
+    styles: string;
+    id: string;
+}
+declare function InlinedStyles(props: Props): React.JSX.Element;
+export default InlinedStyles;

package/types/esm/constants/builder-registered-components.d.mts

@@ -0,0 +1,6 @@
+import type { RegisteredComponent } from '../context/types.js';
+/**
+ * Returns a list of all registered components.
+ * NOTE: This needs to be a function to work around ESM circular dependencies.
+ */
+export declare const getDefaultRegisteredComponents: () => RegisteredComponent[];

package/types/esm/constants/device-sizes.d.mts

@@ -0,0 +1,13 @@
+export type SizeName = 'large' | 'medium' | 'small';
+interface Size {
+    min: number;
+    default: number;
+    max: number;
+}
+export declare const getMaxWidthQueryForSize: (size: SizeName, sizeValues?: Record<SizeName, Size>) => string;
+interface Breakpoints {
+    small?: number;
+    medium?: number;
+}
+export declare const getSizesForBreakpoints: ({ small, medium }: Breakpoints) => Record<SizeName, Size>;
+export {};

package/types/esm/constants/extra-components.d.mts

@@ -0,0 +1,7 @@
+/**
+ * These are in a separate file because React Native does not support them (yet).
+ * Having them in a separate file allows us to override it to be empty in the
+ * React Native SDK.
+ */
+import type { RegisteredComponent } from '../context/types.js';
+export declare const getExtraComponents: () => RegisteredComponent[];

package/types/esm/constants/sdk-version.d.mts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "1.0.27";

package/types/esm/constants/target.d.mts

@@ -0,0 +1,2 @@
+/** This file should be overriden for each framework. Ideally this would be implemented in Mitosis.  */
+export declare const TARGET: any;

package/types/esm/context/builder.context.d.mts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const _default: import("react").Context<any>;
+export default _default;

package/types/esm/context/components.context.d.mts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const _default: import("react").Context<any>;
+export default _default;

package/types/esm/context/index.d.mts

@@ -0,0 +1 @@
+export { default as BuilderContext } from './builder.context.js';

package/types/esm/context/types.d.mts

@@ -0,0 +1,36 @@
+import type { BlocksWrapperProps } from '../components/blocks/blocks-wrapper.js';
+import type { ApiVersion } from '../types/api-version.js';
+import type { BuilderContent } from '../types/builder-content.js';
+import type { ComponentInfo } from '../types/components.js';
+import type { Dictionary, Nullable } from '../types/typescript.js';
+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 extends Pick<BlocksWrapperProps, 'BlocksWrapper' | 'BlocksWrapperProps'> {
+    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>;
+}

package/types/esm/functions/apply-patch-with-mutation.d.mts

@@ -0,0 +1,10 @@
+export type Patch = {
+    path: string;
+    op: 'add' | 'remove' | 'replace';
+    value: any;
+};
+export declare const applyPatchWithMinimalMutationChain: <T extends object>(obj: T, patch: {
+    path: string;
+    op: 'add' | 'remove' | 'replace';
+    value: any;
+}, preserveRoot?: boolean) => T;

package/types/esm/functions/camel-to-kebab-case.d.mts

@@ -0,0 +1 @@
+export declare const camelToKebabCase: (string: string) => string;

package/types/esm/functions/deopt.d.mts

@@ -0,0 +1,4 @@
+/**
+ * Workaround until https://github.com/BuilderIO/qwik/issues/5017 is fixed.
+ */
+export declare function deoptSignal<T>(value: T): T;

package/types/esm/functions/evaluate/browser-runtime/browser.d.mts

@@ -0,0 +1,8 @@
+import type { BuilderRenderState } from '../../../context/types.js';
+import type { ExecutorArgs } from '../helpers.js';
+export declare const runInBrowser: ({ code, builder, context, event, localState, rootSetState, rootState }: ExecutorArgs) => any;
+export declare function flattenState({ rootState, localState, rootSetState }: {
+    rootState: Record<string | symbol, any>;
+    localState: Record<string | symbol, any> | undefined;
+    rootSetState: ((rootState: BuilderRenderState) => void) | undefined;
+}): BuilderRenderState;

package/types/esm/functions/evaluate/browser-runtime/index.d.mts

@@ -0,0 +1 @@
+export { runInBrowser as evaluator } from './browser.js';

package/types/esm/functions/evaluate/choose-eval.d.mts

@@ -0,0 +1,6 @@
+import type { ExecutorArgs } from './helpers.js';
+/**
+ * Even though we have separate runtimes for browser/node/edge, sometimes frameworks will
+ * end up sending the server runtime code to the browser (most notably in dev mode).
+ */
+export declare const chooseBrowserOrServerEval: (args: ExecutorArgs) => any;

package/types/esm/functions/evaluate/edge-runtime/acorn-interpreter.d.mts

@@ -0,0 +1,2 @@
+declare const _default: Class;
+export default _default;

package/types/esm/functions/evaluate/edge-runtime/edge-runtime.d.mts

@@ -0,0 +1,2 @@
+import type { ExecutorArgs } from '../helpers.js';
+export declare const runInEdge: ({ builder, context, event, rootState, localState, rootSetState, code }: ExecutorArgs) => any;

package/types/esm/functions/evaluate/edge-runtime/index.d.mts

@@ -0,0 +1 @@
+export { runInEdge as evaluator } from './edge-runtime.js';

package/types/esm/functions/evaluate/evaluate.d.mts

@@ -0,0 +1,4 @@
+import type { EvaluatorArgs } from './helpers.js';
+type EvalValue = unknown;
+export declare function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression, enableCache }: EvaluatorArgs): EvalValue;
+export {};

package/types/esm/functions/evaluate/helpers.d.mts

@@ -0,0 +1,25 @@
+import type { BuilderContextInterface, BuilderRenderState } from '../../context/types.js';
+import { getUserAttributes } from '../track/helpers.js';
+export type EvaluatorArgs = Omit<ExecutorArgs, 'builder' | 'event'> & {
+    event?: Event;
+    isExpression?: boolean;
+    enableCache: boolean;
+};
+export type BuilderGlobals = {
+    isEditing: boolean | undefined;
+    isBrowser: boolean | undefined;
+    isServer: boolean | undefined;
+    getUserAttributes: typeof getUserAttributes;
+};
+export type ExecutorArgs = Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'> & {
+    code: string;
+    builder: BuilderGlobals;
+    event: Event | undefined;
+};
+export type Executor = (args: ExecutorArgs) => any;
+export type FunctionArguments = ReturnType<typeof getFunctionArguments>;
+export declare const getFunctionArguments: ({ builder, context, event, state }: Pick<ExecutorArgs, "context" | "builder" | "event"> & {
+    state: BuilderRenderState;
+}) => [string, Event | BuilderRenderState | import("../../context/types.js").BuilderRenderContext | BuilderGlobals][];
+export declare const getBuilderGlobals: () => BuilderGlobals;
+export declare const parseCode: (code: string, { isExpression }: Pick<EvaluatorArgs, 'isExpression'>) => string;

package/types/esm/functions/evaluate/index.d.mts

@@ -0,0 +1 @@
+export { evaluate } from './evaluate.js';

package/types/esm/functions/evaluate/node-runtime/index.d.mts

@@ -0,0 +1 @@
+export { runInNode as evaluator } from './node-runtime.js';

package/types/esm/functions/evaluate/node-runtime/init.d.mts

@@ -0,0 +1,13 @@
+import type { IsolateOptions } from 'isolated-vm';
+/**
+ * This function initializes the SDK on a Node server. It handles importing the
+ * `isolated-vm` package which is needed for dynamic bindings.
+ *
+ * NOTE: this function cannot be called on the client. You must call this function
+ * from a server-only location, such as:
+ * - The NextJS Pages router's `_document.tsx`
+ * - Your Remix route's `loader`
+ */
+export declare const initializeNodeRuntime: (args?: {
+    ivmIsolateOptions?: IsolateOptions;
+}) => void;

package/types/esm/functions/evaluate/node-runtime/node-runtime.d.mts

@@ -0,0 +1,11 @@
+import type { IsolateOptions } from 'isolated-vm';
+import type { ExecutorArgs } from '../helpers.js';
+type IsolatedVMImport = typeof import('isolated-vm');
+/**
+ * Set the `isolated-vm` instance to be used by the node runtime.
+ * This is useful for environments that are not able to rely on our
+ * `safeDynamicRequire` trick to import the `isolated-vm` package.
+ */
+export declare const setIvm: (ivm: IsolatedVMImport, options?: IsolateOptions) => void;
+export declare const runInNode: ({ code, builder, context, event, localState, rootSetState, rootState }: ExecutorArgs) => any;
+export {};

package/types/esm/functions/evaluate/node-runtime/safeDynamicRequire.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Overriding usage of `node:module` because of https://github.com/vercel/next.js/issues/60491
+ * This doesn't actually work in production, but it lets the tests pass...
+ * Mono-repo env seems to pull in the SDK differently which allows the eval('require') to work.
+ */
+export declare let safeDynamicRequire: typeof require;

package/types/esm/functions/evaluate/placeholder-runtime.d.mts

@@ -0,0 +1,2 @@
+import type { ExecutorArgs } from './helpers.js';
+export declare const evaluator: (_args: ExecutorArgs) => never;

package/types/esm/functions/evaluate/should-force-browser-runtime-in-node.d.mts

@@ -0,0 +1 @@
+export declare const shouldForceBrowserRuntimeInNode: () => boolean;

package/types/esm/functions/event-handler-name.d.mts

@@ -0,0 +1 @@
+export declare const getEventHandlerName: (key: string) => string;

package/types/esm/functions/extract-text-styles.d.mts

@@ -0,0 +1,4 @@
+/**
+ * Extract styles that apply to text from a style object.
+ */
+export declare const extractTextStyles: (styles: Partial<CSSStyleDeclaration>) => Partial<CSSStyleDeclaration>;

package/types/esm/functions/fast-clone.d.mts

@@ -0,0 +1,4 @@
+/**
+ * We need to serialize values to a string in case there are Proxy values, as is the case with SolidJS etc.
+ */
+export declare const fastClone: <T extends object>(obj: T) => T;

package/types/esm/functions/fetch-builder-props.d.mts

@@ -0,0 +1,53 @@
+import type { ContentVariantsPrps } from '../components/content-variants/content-variants.types.js';
+import type { Dictionary } from '../types/typescript.js';
+import type { GetContentOptions } from './get-content/types.js';
+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 declare const fetchBuilderProps: (_args: GetBuilderPropsOptions) => Promise<ContentVariantsPrps>;
+export {};

package/types/esm/functions/get-block-actions-handler.d.mts

@@ -0,0 +1,8 @@
+import type { BuilderContextInterface } from '../context/types.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+type Options = {
+    block: BuilderBlock;
+} & Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'>;
+type EventHandler = (event: Event) => any;
+export declare const createEventHandler: (value: string, options: Options) => EventHandler;
+export {};

package/types/esm/functions/get-block-actions.d.mts

@@ -0,0 +1,10 @@
+import type { BuilderContextInterface } from '../context/types.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+type Actions = {
+    [index: string]: (event: Event) => any;
+};
+export declare function getBlockActions(options: {
+    block: BuilderBlock;
+    stripPrefix?: boolean;
+} & Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'>): Actions;
+export {};

package/types/esm/functions/get-block-component-options.d.mts

@@ -0,0 +1,2 @@
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare function getBlockComponentOptions(block: BuilderBlock): any;

package/types/esm/functions/get-block-properties.d.mts

@@ -0,0 +1,10 @@
+import type { BuilderContextInterface } from '../context/types.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare function getBlockProperties({ block, context }: {
+    block: BuilderBlock;
+    context: BuilderContextInterface;
+}): {
+    'builder-id': string;
+    style: string | Partial<CSSStyleDeclaration>;
+    href: any;
+};

package/types/esm/functions/get-builder-search-params/index.d.mts

@@ -0,0 +1,9 @@
+import type { QueryObject } from '../../helpers/search/search.js';
+/**
+ * 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 declare const getBuilderSearchParams: (_options: QueryObject | URLSearchParams | undefined) => QueryObject;
+export declare const getBuilderSearchParamsFromWindow: () => QueryObject;

package/types/esm/functions/get-class-prop-name.d.mts

@@ -0,0 +1 @@
+export declare const getClassPropName: () => "className" | "class";

package/types/esm/functions/get-content/generate-content-url.d.mts

@@ -0,0 +1,2 @@
+import type { GetContentOptions } from './types.js';
+export declare const generateContentUrl: (options: GetContentOptions) => URL;

package/types/esm/functions/get-content/index.d.mts

@@ -0,0 +1,18 @@
+import type { BuilderContent } from '../../types/builder-content.js';
+import type { GetContentOptions } from './types.js';
+/**
+ * Returns the first content entry that matches the given options.
+ */
+export declare function fetchOneEntry(options: GetContentOptions): Promise<BuilderContent | null>;
+type ContentResults = {
+    results: BuilderContent[];
+};
+/**
+ * @internal Exported only for testing purposes. Do not use.
+ */
+export declare const _processContentResult: (options: GetContentOptions, content: ContentResults, url?: URL) => Promise<BuilderContent[]>;
+/**
+ * Returns a paginated array of entries that match the given options.
+ */
+export declare function fetchEntries(options: GetContentOptions): Promise<BuilderContent[]>;
+export {};

package/types/esm/functions/get-content/types.d.mts

@@ -0,0 +1,139 @@
+export interface GetContentOptions {
+    /** The model to get content for (required) */
+    model: string;
+    /** Your public API key (required) */
+    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, any> & {
+        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 `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 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.
+     *
+     * Currently, the only available API version is `v3`.
+     */
+    apiVersion?: '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;
+    /**
+     * Optional override of the `fetch` function. (Defaults to global `fetch`)
+     */
+    fetch?: (input: string, init?: object) => Promise<any>;
+    /**
+     * Optional fetch options to be passed as the second argument to the `fetch` function.
+     */
+    fetchOptions?: object;
+}

package/types/esm/functions/get-env.d.mts

@@ -0,0 +1,2 @@
+export declare const validEnvList: string[];
+export declare const getEnv: () => string;

package/types/esm/functions/get-fetch.d.mts

@@ -0,0 +1 @@
+export declare const fetch: typeof globalThis.fetch;

package/types/esm/functions/get-global-this.d.mts

@@ -0,0 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
+type Global = typeof global | typeof window | typeof self | typeof globalThis;
+export declare function getGlobalThis(): Global;
+export {};

package/types/esm/functions/get-processed-block.d.mts

@@ -0,0 +1,10 @@
+import type { BuilderContextInterface } from '../context/types.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare function getProcessedBlock({ block, context, shouldEvaluateBindings, localState, rootState, rootSetState }: {
+    block: BuilderBlock;
+    /**
+     * In some cases, we want to avoid evaluating bindings and only want framework-specific block transformation. It is
+     * also sometimes too early to consider bindings, e.g. when we might be looking at a repeated block.
+     */
+    shouldEvaluateBindings: boolean;
+} & Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'>): BuilderBlock;

package/types/esm/functions/get-style.d.mts

@@ -0,0 +1,12 @@
+import type { BuilderContextInterface } from '../context/types.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare const getStyle: ({ block, context }: {
+    block: BuilderBlock;
+    context: BuilderContextInterface;
+}) => string | Partial<CSSStyleDeclaration>;
+/**
+ * Svelte does not support style attribute as an object so we need to flatten it.
+ *
+ * Additionally, Svelte, Vue and other frameworks use kebab-case styles, so we need to convert them.
+ */
+export declare function mapStyleObjToStrIfNeeded(style: Partial<CSSStyleDeclaration>): string | Partial<CSSStyleDeclaration>;