@builder.io/sdk-qwik 0.5.5 → 0.5.7

package/types/src/functions/evaluate/browser-runtime/browser.d.ts

@@ -0,0 +1,4 @@
+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: Record<string | symbol, any>, localState: Record<string | symbol, any> | undefined, rootSetState: ((rootState: BuilderRenderState) => void) | undefined): BuilderRenderState;

package/types/src/functions/evaluate/browser-runtime/index.d.ts

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

package/types/src/functions/evaluate/evaluate.d.ts

@@ -0,0 +1,10 @@
+import type { BuilderContextInterface, BuilderRenderState } from '../../context/types.js';
+import type { ExecutorArgs } from './types.js';
+export declare function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression }: {
+    code: string;
+    event?: Event;
+    isExpression?: boolean;
+} & Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'>): any;
+export declare const runInBrowser: ({ useCode, builder, context, event, localState, rootSetState, rootState }: ExecutorArgs) => any;
+export declare const runInNode: (args: ExecutorArgs) => any;
+export declare function flattenState(rootState: Record<string | symbol, any>, localState: Record<string | symbol, any> | undefined, rootSetState: ((rootState: BuilderRenderState) => void) | undefined): BuilderRenderState;

package/types/src/functions/evaluate/helpers.d.ts

@@ -0,0 +1,18 @@
+import type { BuilderContextInterface, BuilderRenderState } from '../../context/types.js';
+import type { getUserAttributes } from '../track/helpers.js';
+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 | undefined][];

package/types/src/functions/evaluate/index.d.ts

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

package/types/src/functions/evaluate/node-runtime/index.d.ts

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

package/types/src/functions/evaluate/node-runtime/node-runtime.d.ts

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

package/types/src/functions/evaluate/non-node-runtime/acorn-interpreter.d.ts

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

package/types/src/functions/evaluate/non-node-runtime/index.d.ts

@@ -0,0 +1 @@
+export { runInNonNode } from './non-node-runtime.js';

package/types/{functions/evaluate → src/functions/evaluate/non-node-runtime}/non-node-runtime.d.ts

@@ -1,2 +1,2 @@
-import type { ExecutorArgs } from './types';
+import type { ExecutorArgs } from '../types';
 export declare const runInNonNode: ({ builder, context, event, rootState, localState, rootSetState, useCode }: ExecutorArgs) => any;

package/types/src/functions/evaluate/placeholder-runtime.d.ts

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

package/types/src/functions/evaluate/types.d.ts

@@ -0,0 +1,11 @@
+import type { BuilderContextInterface } from '../../context/types';
+export type ExecutorArgs = Pick<BuilderContextInterface, 'localState' | 'context' | 'rootState' | 'rootSetState'> & {
+    useCode: string;
+    builder: {
+        isEditing: boolean | undefined;
+        isBrowser: boolean | undefined;
+        isServer: boolean | undefined;
+    };
+    event: Event | undefined;
+};
+export type Executor = (args: ExecutorArgs) => any;

package/types/src/functions/event-handler-name.d.ts

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

package/types/src/functions/extract-text-styles.d.ts

@@ -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/src/functions/fast-clone.d.ts

@@ -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/src/functions/fetch-builder-props.d.ts

@@ -0,0 +1,39 @@
+import type { ContentVariantsProps } from '../components/content-variants/content-variants.types';
+import type { Dictionary } from '../types/typescript';
+import type { GetContentOptions } from './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;
+});
+/**
+ * Fetches builder content, and returns it along with sensible defaults for other props that `Content` needs to render.
+ */
+export declare const fetchBuilderProps: (_args: GetBuilderPropsOptions) => Promise<ContentVariantsProps>;
+export {};

package/types/src/functions/get-block-actions-handler.d.ts

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

package/types/src/functions/get-block-actions.d.ts

@@ -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/src/functions/get-block-component-options.d.ts

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

package/types/src/functions/get-block-properties.d.ts

@@ -0,0 +1,11 @@
+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 | undefined;
+    style: string | Partial<CSSStyleDeclaration> | undefined;
+    class: string;
+    href: any;
+};

package/types/src/functions/get-builder-search-params/index.d.ts

@@ -0,0 +1,12 @@
+type QueryObject = Record<string, string | string[]>;
+export declare 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 declare const getBuilderSearchParams: (_options: QueryObject | URLSearchParams | undefined) => QueryObject;
+export declare const getBuilderSearchParamsFromWindow: () => QueryObject;
+export declare const normalizeSearchParams: (searchParams: QueryObject | URLSearchParams) => QueryObject;
+export {};

package/types/src/functions/get-content/generate-content-url.d.ts

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

package/types/src/functions/get-content/index.d.ts

@@ -0,0 +1,29 @@
+import type { BuilderContent } from '../../types/builder-content.js';
+import type { GetContentOptions } from './types.js';
+/**
+ * Returns a the first entry that matches the given options.
+ */
+export declare function fetchOneEntry(options: GetContentOptions): Promise<BuilderContent | null>;
+/**
+ * @deprecated
+ * Consider using `fetchBuilderProps` instead for easier setup.
+ *
+ * NOTE: `getContent` was renamed to `fetchOneEntry` and will be removed in a future release.
+ */
+export declare const getContent: typeof fetchOneEntry;
+type ContentResults = {
+    results: BuilderContent[];
+};
+/**
+ * Exported only for testing purposes. Should not be used directly.
+ */
+export declare const _processContentResult: (options: GetContentOptions, content: ContentResults, url?: URL) => Promise<ContentResults>;
+/**
+ * Returns a paginated array of entries that match the given options.
+ */
+export declare function fetchEntries(options: GetContentOptions): Promise<ContentResults | null>;
+/**
+ * @deprecated Use `fetchEntries` instead.
+ */
+export declare const getAllContent: typeof fetchEntries;
+export {};

package/types/src/functions/get-content/types.d.ts

@@ -0,0 +1,51 @@
+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;
+    /** User attributes to target on, such as { urlPath: '/foo', device: 'mobile', ...etc } */
+    userAttributes?: (Record<string, string> & {
+        urlPath?: string;
+    }) | null;
+    /** Custom 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 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';
+}

package/types/src/functions/get-fetch.d.ts

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

package/types/src/functions/get-global-this.d.ts

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

package/types/src/functions/get-processed-block.d.ts

@@ -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/{functions/get-block-styles.d.ts → src/functions/get-react-native-block-styles.d.ts}

@@ -1,6 +1,7 @@
 import type { BuilderContextInterface } from '../context/types.js';
 import type { BuilderBlock } from '../types/builder-block.js';
-export declare function getBlockStyles({ block, context, }: {
+export declare function getReactNativeBlockStyles({ block, context, blockStyles }: {
     block: BuilderBlock;
     context: BuilderContextInterface;
-}): Partial<CSSStyleDeclaration>;
+    blockStyles: any;
+}): CSSStyleDeclaration | Record<string, string | undefined>;

package/types/src/functions/if-target.d.ts

@@ -0,0 +1,7 @@
+type Target = import('../types/targets').Target;
+export declare function ifTarget<A, B>({ targets, doThing, elseThing }: {
+    targets: Target[];
+    doThing: () => A;
+    elseThing?: () => B;
+}): A | B | undefined;
+export {};

package/types/src/functions/is-browser.d.ts

@@ -0,0 +1 @@
+export declare function isBrowser(): boolean;

package/types/src/functions/is-editing.d.ts

@@ -0,0 +1 @@
+export declare function isEditing(): boolean;

package/types/src/functions/is-iframe.d.ts

@@ -0,0 +1 @@
+export declare function isIframe(): boolean;

package/types/src/functions/is-non-node-server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Identifies non-node server runtimes (edge, workers, serverless, etc.)
+ */
+export declare function isNonNodeServer(): boolean;

package/types/src/functions/is-previewing.d.ts

@@ -0,0 +1 @@
+export declare function isPreviewing(): boolean;

package/types/src/functions/on-change.d.ts

@@ -0,0 +1,7 @@
+export declare const onChangeProxySymbol: unique symbol;
+/**
+ * Deeply observe an object and run a callback when it changes
+ *
+ * See ./on-change.test.ts for more info
+ */
+export declare function onChange<T extends object = any>(obj: T, cb: () => void): T;

package/types/src/functions/register-component.d.ts

@@ -0,0 +1,15 @@
+import type { RegisteredComponent } from '../context/types.js';
+import type { ComponentInfo } from '../types/components.js';
+/**
+ * @deprecated.  Use the `customComponents` prop in RenderContent instead to provide your custom components to the builder SDK.
+ */
+export declare const components: RegisteredComponent[];
+/**
+ * @deprecated.  Use the `customComponents` prop in RenderContent instead to provide your custom components to the builder SDK.
+ */
+export declare function registerComponent(component: any, info: ComponentInfo): void;
+export declare const createRegisterComponentMessage: (info: ComponentInfo) => {
+    type: string;
+    data: ComponentInfo;
+};
+export declare const serializeComponentInfo: ({ inputs, ...info }: ComponentInfo) => ComponentInfo;

package/types/src/functions/register.d.ts

@@ -0,0 +1,16 @@
+import type { BuilderBlock } from '../types/builder-block.js';
+import type { DeepPartial } from '../types/deep-partial.js';
+export interface InsertMenuItem {
+    name: string;
+    icon?: string;
+    item: DeepPartial<BuilderBlock>;
+}
+export interface InsertMenuConfig {
+    name: string;
+    priority?: number;
+    persist?: boolean;
+    advanced?: boolean;
+    items: InsertMenuItem[];
+}
+export declare function register(type: 'insertMenu', info: InsertMenuConfig): void;
+export declare function register(type: string, info: any): void;

package/types/src/functions/sanitize-react-native-block-styles.d.ts

@@ -0,0 +1,3 @@
+type Styles = Record<string, string | number>;
+export declare const sanitizeReactNativeBlockStyles: (styles: Styles) => Styles;
+export {};

package/types/src/functions/set-editor-settings.d.ts

@@ -0,0 +1,4 @@
+export type Settings = {
+    customInsertMenu?: boolean;
+};
+export declare function setEditorSettings(newSettings: Settings): void;

package/types/src/functions/set.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Minimal implementation of lodash's _.set
+ * https://lodash.com/docs/4.17.15#set
+ *
+ * See ./set.test.ts for usage examples
+ */
+export declare const set: (obj: any, _path: string | string[], value: any) => any;

package/types/src/functions/track/helpers.d.ts

@@ -0,0 +1,5 @@
+export declare const getUserAttributes: () => {
+    urlPath: string | undefined;
+    host: string | undefined;
+    device: string;
+};

package/types/{functions/track.d.ts → src/functions/track/index.d.ts}

@@ -1,4 +1,5 @@
-import type { CanTrack } from '../types/can-track.js';
+import type { CanTrack } from '../../types/can-track.js';
+import type { Dictionary } from '../../types/typescript.js';
 interface Event {
     /**
      * The type of your event.
@@ -16,9 +17,9 @@ interface Event {
          */
         ownerId: string;
         /**
-         * Stringified JSON object containing any additional metadata you want to track.
+         * (Optional) metadata that you want to provide with your event.
          */
-        metadata?: string;
+        metadata?: Dictionary<any>;
         /**
          * Session ID of the user. This is provided by the SDK by checking session storage.
          */
@@ -34,23 +35,17 @@ interface Event {
         [index: string]: any;
     };
 }
-declare type EventProperties = Pick<Event, 'type'> & Pick<Event['data'], 'contentId' | 'variationId'> & {
+type EventProperties = Pick<Event, 'type'> & Pick<Event['data'], 'contentId' | 'variationId' | 'metadata'> & {
     /**
      * Your organization's API key.
      */
     apiKey: Event['data']['ownerId'];
-    /**
-     * (Optional) metadata that you want to provide with your event.
-     */
-    metadata?: {
-        [index: string]: any;
-    };
     /**
      * (Optional) Any additional (non-metadata) properties to add to the event.
      */
     [index: string]: any;
 };
-export declare type EventProps = EventProperties & CanTrack;
+export type EventProps = EventProperties & CanTrack;
 export declare function _track(eventProps: EventProps): Promise<void | Response>;
 export declare const track: (args: EventProperties) => Promise<void | Response>;
 export {};

package/types/src/functions/track/interaction.d.ts

@@ -0,0 +1,13 @@
+type Offset = {
+    x: number;
+    y: number;
+};
+export declare const getInteractionPropertiesForEvent: (event: MouseEvent) => {
+    targetBuilderElement: string | undefined;
+    metadata: {
+        targetOffset: Offset | undefined;
+        builderTargetOffset: Offset | undefined;
+        builderElementIndex: number | undefined;
+    };
+};
+export {};

package/types/src/functions/transform-block-properties.d.ts

@@ -0,0 +1 @@
+export declare function transformBlockProperties<T>(properties: T): T;

package/types/src/functions/transform-block.d.ts

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

package/types/src/helpers/ab-tests.d.ts

@@ -0,0 +1,9 @@
+import type { CanTrack } from '../types/can-track.js';
+import type { BuilderContent } from '../types/builder-content.js';
+import type { Nullable } from '../types/typescript.js';
+export declare const handleABTestingSync: ({ item, canTrack }: {
+    item: Nullable<BuilderContent>;
+} & CanTrack) => Nullable<BuilderContent>;
+export declare const handleABTesting: ({ item, canTrack }: {
+    item: BuilderContent;
+} & CanTrack) => Promise<BuilderContent>;

package/types/src/helpers/canTrack.d.ts

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

package/types/src/helpers/cookie.d.ts

@@ -0,0 +1,19 @@
+import type { CanTrack } from '../types/can-track.js';
+type GetCookieArgs = {
+    name: string;
+} & CanTrack;
+export declare 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 declare const getCookie: (args: GetCookieArgs) => Promise<string | undefined>;
+/**
+ * NOTE: This function is `async` because its react-native override is async. Do not remove the `async` keyword!
+ */
+export declare const setCookie: ({ name, value, expires, canTrack }: {
+    name: string;
+    value: string;
+    expires?: Date | undefined;
+} & CanTrack) => Promise<void>;
+export {};

package/types/src/helpers/css.d.ts

@@ -0,0 +1,7 @@
+export declare const convertStyleMapToCSSArray: (style: Partial<CSSStyleDeclaration>) => string[];
+export declare const convertStyleMapToCSS: (style: Partial<CSSStyleDeclaration>) => string;
+export declare const createCssClass: ({ mediaQuery, className, styles }: {
+    mediaQuery?: string | undefined;
+    className: string;
+    styles: Partial<CSSStyleDeclaration>;
+}) => string;

package/types/src/helpers/flatten.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert deep object to a flat object with dots
+ *
+ * { foo: { bar: 'baz' }} -> { 'foo.bar': 'baz' }
+ */
+export declare function flatten<T extends Record<string, any>>(object: T, path?: string | null, separator?: string): T;

package/types/src/helpers/localStorage.d.ts

@@ -0,0 +1,9 @@
+import type { CanTrack } from '../types/can-track.js';
+import type { Nullable } from './nullable.js';
+export declare const getLocalStorageItem: ({ key, canTrack }: {
+    key: string;
+} & CanTrack) => Nullable<string>;
+export declare const setLocalStorageItem: ({ key, canTrack, value }: {
+    key: string;
+    value: string;
+} & CanTrack) => void;

package/types/src/helpers/logger.d.ts

@@ -0,0 +1,6 @@
+export declare const logger: {
+    log: (...message: any[]) => void;
+    error: (...message: any[]) => void;
+    warn: (...message: any[]) => void;
+    debug: (...message: any[]) => void;
+};

package/types/src/helpers/nullable.d.ts

@@ -0,0 +1,2 @@
+export type Nullable<T> = T | null | undefined;
+export declare const checkIsDefined: <T>(maybeT: Nullable<T>) => maybeT is T;

package/types/src/helpers/preview-lru-cache/get.d.ts

@@ -0,0 +1,2 @@
+import type { BuilderContent } from '../../types/builder-content';
+export declare function getPreviewContent(_searchParams: URLSearchParams): BuilderContent | undefined;

package/types/src/helpers/preview-lru-cache/init.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This is an LRU cache to hold preview content on the server-side.
+ *
+ * Note: This logic is only used by the NextJS SDK.
+ */
+export declare function init(): void;

package/types/src/helpers/preview-lru-cache/set.d.ts

@@ -0,0 +1,7 @@
+import type { BuilderContent } from '../../types/builder-content';
+export declare function postPreviewContent({ key, value }: {
+    key: string;
+    value: BuilderContent;
+}): Promise<{
+    [x: string]: BuilderContent;
+}>;

package/types/src/helpers/sessionId.d.ts

@@ -0,0 +1,6 @@
+import type { CanTrack } from '../types/can-track.js';
+export declare const getSessionId: ({ canTrack }: CanTrack) => Promise<string | undefined>;
+export declare const createSessionId: () => string;
+export declare const setSessionId: ({ id, canTrack }: {
+    id: string;
+} & CanTrack) => Promise<void>;

package/types/src/helpers/time.d.ts

@@ -0,0 +1 @@
+export declare const getCurrentDatePlusMinutes: (minutes?: number) => Date;

package/types/src/helpers/url.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Only gets one level up from hostname
+ * wwww.example.com -> example.com
+ * www.example.co.uk -> example.co.uk
+ */
+export declare const getTopLevelDomain: (host: string) => string;

package/types/src/helpers/uuid.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @credit https://stackoverflow.com/a/2117523
+ */
+export declare function uuidv4(): string;
+/**
+ * Slightly cleaner and smaller UUIDs
+ */
+export declare function uuid(): string;

package/types/src/helpers/visitorId.d.ts

@@ -0,0 +1,6 @@
+import type { CanTrack } from '../types/can-track.js';
+export declare const getVisitorId: ({ canTrack }: CanTrack) => string | undefined;
+export declare const createVisitorId: () => string;
+export declare const setVisitorId: ({ id, canTrack }: {
+    id: string;
+} & CanTrack) => void;