@schibsted/pulse-sdk 8.0.0-alpha.16 → 8.0.0-alpha.18

package/dist/types/leaveTrackingTpaas/index.d.ts

@@ -0,0 +1,28 @@
+import type { ILeave } from '@schibsted/tpaas-schemas';
+import type { LeaveTrackingOptions, TrackViewEventOptions } from '../types';
+import type { LeaveObjectTypes, Listener, TrackMethod } from './types';
+export declare function addTpaasLeaveTracking({ objectElement, pageElement, schema, objectResizable, heightBuilder, trackMethod, }: LeaveTrackingOptions & {
+    schema: LeaveObjectTypes;
+    trackMethod: TrackMethod;
+}): void;
+export declare function leaveTpaasTrackingIsActive(): boolean;
+export declare function removeTpaasLeaveTracking(): void;
+/**
+ * Update leave tracking
+ * @param objectElement new object element to track
+ * @param pageElement new page element to track
+ * @param resetProperties if ALL engagement properties should be reset (duration, scroll etc.)
+ */
+export declare function updateTpaasLeaveTracking(objectElement: Element, pageElement: Element, resetProperties: boolean): void;
+export declare const resetTpaasViewedContent: () => void;
+export declare function trackTpaasActiveLeave(): void;
+export declare function trackTpaasLeave(): void;
+export declare function getTpaasLeaveObject(): ILeave;
+export declare function updateTpaasViewedContent(objectElement: Element, pageElement: Element): void;
+export declare const calculateScrolledPixels: (element: Element) => number;
+export declare const calculateScrollPosition: (element: Element) => number;
+export declare function addEventListeners(events: string[], handler: () => void, options?: boolean | AddEventListenerOptions): Listener[];
+export declare function removeEventListeners(eventListeners: Listener[], options?: {
+    capture?: boolean;
+}): Listener[];
+export declare function shouldEnableLeaveTracking(leaveOptions: TrackViewEventOptions['leaveTracking']): leaveOptions is LeaveTrackingOptions;

package/dist/types/leaveTrackingTpaas/types.d.ts

@@ -0,0 +1,45 @@
+import type { ILeave, ITpaasEvent } from '@schibsted/tpaas-schemas';
+/**
+ * @typedef BrowserEvents
+ */
+export declare enum BrowserEvents {
+    BEFORE_UNLOAD = "beforeunload",
+    PAGE_HIDE = "pagehide",
+    POP_STATE = "popstate",
+    VISIBILITY_CHANGE = "visibilitychange",
+    SCROLL = "scroll",
+    RESIZE = "resize",
+    MOUSEDOWN = "mousedown",
+    MOUSEMOVE = "mousemove",
+    KEYDOWN = "keydown",
+    TOUCHSTART = "touchstart"
+}
+export type Listener = [name: string, listener: () => void];
+/**
+ * @typedef ActivityDuration
+ */
+export type ActivityDuration = {
+    value: number;
+    interval: number | undefined;
+    timeSinceLastActivity: number;
+};
+/**
+ * Used to provide extra height to view %-calculations for objects that have fake-scrolls or similar
+ * For instance if you have an element that captures scroll for about 1000px
+ * you would report totalHeight 1000px and then viewedHeight 0px if the user had not yet started scrolling, 500px if
+ * scrolled halfway through or 1000px if the user had scrolled to the end or past that element
+ */
+export interface AdditionalHeightInfo {
+    /**
+     * The number of px to add to the object & page height
+     */
+    totalHeight: number;
+    /**
+     * The number of px to add to the users current scroll depth
+     */
+    viewedHeight: number;
+}
+export type TrackMethod = (leave: ILeave) => void;
+export type LeaveObjectTypes = Extract<ITpaasEvent, {
+    eventType: 'Leave';
+}>['object']['objectType'];

package/dist/types/network-browser.d.ts

@@ -0,0 +1,5 @@
+import type { EventInput } from './types';
+export default function send(url: string, data: EventInput | EventInput[], sdkConfig: {
+    useBeaconWhenAvailable: boolean;
+    useBeacon: boolean;
+}): Promise<unknown>;

package/dist/types/network.d.ts

@@ -0,0 +1,4 @@
+export default function send(url: string, data: unknown, state: {
+    username?: string;
+    password?: string;
+}): Promise<Response>;

package/dist/types/remoteConfig/index.d.ts

@@ -0,0 +1,32 @@
+declare const CIS_KEY = "cis";
+declare const COLLECTOR_KEY = "collector";
+export type RemoteConfigServices = {
+    [CIS_KEY]: string;
+    [COLLECTOR_KEY]: string;
+};
+export type RemoteConfig = {
+    version: number;
+    scopes: {
+        [key: string]: {
+            services: RemoteConfigServices;
+        };
+    };
+    'ttl-minutes'?: number;
+};
+export type RemoteConfigMetadata = {
+    remoteConfigUrl: string;
+    updatedAt: string;
+};
+export type RemoteConfigPersistence = {
+    config: RemoteConfig;
+    metadata: RemoteConfigMetadata;
+};
+export declare function fetchRemoteConfig(url: string): Promise<RemoteConfig>;
+export declare function fetchRemoteConfigWithRetry(url: string, retries?: number): Promise<RemoteConfig>;
+export declare function readConfigFromStorage(): RemoteConfigPersistence | null;
+export declare function clearConfigFromStorage(): boolean;
+export declare function clearInMemoryConfig(): void;
+export declare function shouldSyncRemoteConfig(url: string, config?: RemoteConfig, metadata?: RemoteConfigMetadata): boolean;
+export declare function resolveConfigServicesByTag(tag?: string, config?: RemoteConfig): RemoteConfigServices | null;
+export declare function syncRemoteConfig(tag: string | undefined, url: string): Promise<RemoteConfigServices | null>;
+export {};

package/dist/types/tracker-proxy/consts.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Keep those files in sync between the SDK and the extension:
+ * - workspaces/sdk/src/tracker-proxy/consts.ts
+ * - workspaces/tracker-proxy/src/consts.ts
+ *
+ * SDK package is imported in the tracker-proxy package, but only in the development environment
+ * to generate the types for the proxy client. However, we do not want to import constants from
+ * the SDK in the tracker-proxy package, as that would mean runtime dependency.
+ * We also cannot import from the tracker-proxy package in the SDK as that would
+ * create a circular dependency, so we keep the constants in sync manually.
+ */
+import type Tracker from '../Tracker';
+export declare const MESSAGE_PREFIX = "pulse-tracker-proxy";
+export declare const MESSAGE_TYPE_REQUEST = "pulse-tracker-proxy:request";
+export declare const MESSAGE_TYPE_ACK = "pulse-tracker-proxy:ack";
+export declare const MESSAGE_TYPE_INVOKE = "pulse-tracker-proxy:invoke";
+export declare const MESSAGE_TYPE_RETURN = "pulse-tracker-proxy:return";
+export declare const MESSAGE_TYPE_RETURN_ERROR = "pulse-tracker-proxy:return-error";
+export declare const ALLOWED_METHODS: readonly ["track"];
+export declare const TPAAS_ALLOWED_METHODS: readonly ["trackAnonymousViewUIElement", "trackEngagementAudio", "trackEngagementForm", "trackEngagementHealthUIElement", "trackEngagementOffer", "trackEngagementTeaser", "trackEngagementUIElement", "trackEngagementVideo", "trackEngagementVideoAd", "trackEngagementWidget", "trackCompletedHealthAction", "trackImpressionAdSlot", "trackImpressionForm", "trackImpressionHealthUIElement", "trackImpressionOffer", "trackImpressionPlayer", "trackImpressionTeaser", "trackImpressionUIElement", "trackImpressionWidget", "trackLeaveArticle", "trackLeaveAudioPage", "trackLeaveError", "trackLeaveFrontpage", "trackLeaveLandingpage", "trackLeaveListing", "trackLeaveLockedArticle", "trackLeaveLockedAudio", "trackLeaveLockedAudioPage", "trackLeaveLockedVideo", "trackLeaveLockedVideoPage", "trackLeavePage", "trackLeaveVideoPage", "trackLeaveWeather", "trackViewArticle", "trackViewAudio", "trackViewAudioPage", "trackViewError", "trackViewFrontpage", "trackViewHealthPage", "trackViewLandingpage", "trackViewListing", "trackViewLockedArticle", "trackViewLockedAudio", "trackViewLockedAudioPage", "trackViewLockedVideo", "trackViewLockedVideoPage", "trackViewPage", "trackViewTitle", "trackViewVideo", "trackViewVideoPage", "trackViewWeather"];
+export declare function isPulseProxyMessage(message: unknown): message is Message;
+export type TrackInvocation = {
+    method: 'track';
+    args: Parameters<Tracker['track']>;
+};
+type TpaasAllowedMethodsType = (typeof TPAAS_ALLOWED_METHODS)[number];
+export interface TpaasInvocation {
+    method: TpaasAllowedMethodsType;
+    args: Parameters<Tracker[TpaasAllowedMethodsType]>;
+}
+export type Message = {
+    type: typeof MESSAGE_TYPE_REQUEST;
+} | {
+    type: typeof MESSAGE_TYPE_ACK;
+} | {
+    type: typeof MESSAGE_TYPE_INVOKE;
+    payload: TrackInvocation | TpaasInvocation;
+} | {
+    type: typeof MESSAGE_TYPE_RETURN;
+    payload: unknown;
+} | {
+    type: typeof MESSAGE_TYPE_RETURN_ERROR;
+    error: string;
+};
+export {};

package/dist/types/tracker-proxy/proxy-provider.d.ts

@@ -0,0 +1,2 @@
+import type Tracker from '../Tracker';
+export declare function startProxyProviderListener(tracker: Tracker): () => void;

package/dist/types/types.d.ts

@@ -0,0 +1,93 @@
+import type { ILeaveAudio, ILeaveStories } from '@schibsted/tpaas-schemas';
+import type { v4 } from 'uuid';
+import type { Session } from './builders';
+import type { AnonymousTrackerEventInput } from './builders/events-anonymous-node';
+import type { IdentityEventInput, RoutableEventInput, TrackerEventInput } from './builders/events-node';
+import type { AdditionalHeightInfo } from './leaveTracking/types';
+/**
+ * @typedef EventInput
+ */
+export type EventInput = Record<string, unknown>;
+declare global {
+    interface Navigator {
+        userLanguage?: string;
+    }
+}
+/**
+ * Makes the type T allow Promise or non-promise version of itself and any nested objects or array content recursively
+ */
+export type Promisable<T> = T extends Record<PropertyKey, unknown> ? {
+    [K in keyof T]: Promisable<T[K]>;
+} | Promise<T> : T extends Array<infer U> ? Array<Promisable<U>> | Promise<Array<Promisable<U>>> : Promise<T> | T;
+export type PromisableRecord<T> = {
+    [K in keyof T]: Promisable<T[K]>;
+};
+export type BaseEvent = {
+    '@id': ReturnType<typeof v4>;
+    creationDate: string;
+    session: Session;
+};
+export type BaseAnonymousEvent = {
+    '@id': ReturnType<typeof v4>;
+    creationDate: string;
+};
+export type EventInputTypesByTrackingMethod = {
+    identity: PromisableRecord<IdentityEventInput>;
+    trackerEvent: PromisableRecord<TrackerEventInput>;
+    engagementEvent: PromisableRecord<TrackerEventInput>;
+    routableEvent: PromisableRecord<RoutableEventInput>;
+};
+export type AnonymousEventInputTypesByTrackingMethod = {
+    trackerEvent: PromisableRecord<AnonymousTrackerEventInput>;
+    engagementEvent: PromisableRecord<AnonymousTrackerEventInput>;
+};
+/**
+ * Input for {@link AudioPageLeaveTrackingOptions.leaveAudioBuilder}. Omits `activityDurationMs` and
+ * `durationMs` because those are copied automatically from the computed `leave` engagement
+ * metrics when the Leave AudioPage event fires.
+ */
+export type LeaveAudioInput = Omit<ILeaveAudio, 'activityDurationMs' | 'durationMs'>;
+/**
+ * Input for {@link VideoPageLeaveTrackingOptions.leaveStoriesBuilder}. Omits `activityDurationMs` and
+ * `durationMs` because those are copied automatically from the computed `leave` engagement
+ * metrics when the Leave VideoPage event fires.
+ */
+export type LeaveStoriesInput = Omit<ILeaveStories, 'activityDurationMs' | 'durationMs'>;
+export type TrackViewEventOptions = {
+    leaveTracking: LeaveTrackingOptions | LeaveTrackingDisabled;
+};
+export type LeaveTrackingOptions = {
+    objectElement: HTMLElement;
+    pageElement?: HTMLElement;
+    objectResizable?: boolean;
+    heightBuilder?: () => AdditionalHeightInfo;
+};
+export type LeaveTrackingDisabled = false;
+/**
+ * Leave tracking options for {@link Tracker.trackViewAudioPage}.
+ * Extends {@link LeaveTrackingOptions} with an optional builder for audio engagement statistics.
+ */
+export type AudioPageLeaveTrackingOptions = LeaveTrackingOptions & {
+    /**
+     * Called at leave time to provide audio engagement statistics for the Leave AudioPage event.
+     * If not provided, all audio engagement fields default to `0`.
+     */
+    leaveAudioBuilder?: () => LeaveAudioInput;
+};
+export type TrackViewAudioPageOptions = {
+    leaveTracking: AudioPageLeaveTrackingOptions | LeaveTrackingDisabled;
+};
+/**
+ * Leave tracking options for {@link Tracker.trackViewVideoPage}.
+ * Extends {@link LeaveTrackingOptions} with an optional builder for story carousel statistics.
+ */
+export type VideoPageLeaveTrackingOptions = LeaveTrackingOptions & {
+    /**
+     * Called at leave time to provide story carousel statistics for the Leave VideoPage event.
+     * If not provided, `leaveStories` will be omitted from the Leave VideoPage event.
+     */
+    leaveStoriesBuilder?: () => LeaveStoriesInput;
+};
+export type TrackViewVideoPageOptions = {
+    leaveTracking: VideoPageLeaveTrackingOptions | LeaveTrackingDisabled;
+};

package/dist/types/visibility-observer/index.d.ts

@@ -0,0 +1,38 @@
+type ComponentViewCallback = (node: HTMLElement) => void;
+/**
+ * Observes visibility of elements matching a selector using MutationObserver and IntersectionObserver.
+ */
+export declare class VisibilityObserver {
+    private callback;
+    private mutationObserver;
+    private intersectionObserver;
+    private selector;
+    /**
+     * @param callback The callback function to be executed when an element becomes visible.
+     */
+    constructor(callback: ComponentViewCallback);
+    /**
+     * Tracks visibility of elements matching {@link selector}, triggering {@link callback} when an element is over 2/3 visible.
+     * Uses {@link https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver | MutationObserver} to monitor the DOM for dynamically loaded content.
+     * Callback is invoked only once per element.
+     * @param selector The CSS selector for elements to track.
+     * @throws Error if called more than once.
+     */
+    observe(selector: string): void;
+    /**
+     * @returns {HTMLElement[]} An array of elements that match the selector in the document.
+     */
+    elements(): HTMLElement[];
+    private setupObservers;
+    private setupIntersectionObserver;
+    private setupMutationObserver;
+    private handleAddedNodes;
+    private handleRemovedNodes;
+    private processHtmlNodes;
+    private processMatchingElements;
+    private nodeMatchesOrContainsSelector;
+    private extractElementsToTrack;
+    private observeIntersection;
+    private observeMutations;
+}
+export {};

package/dist/types/warnOnce.d.ts

@@ -0,0 +1,2 @@
+declare const warnOnce: (id: string, ...data: Array<unknown>) => void;
+export default warnOnce;

package/dist/types/wrapper/engagement/ui-element/event-builder.d.ts

@@ -0,0 +1,3 @@
+import type { Page, Promisable } from '../../types/index.js';
+import type { ClickUIElementEvent, ClickUIElementInputProperties } from './types.js';
+export declare const buildClickUIElementEvent: (inputProperties: ClickUIElementInputProperties, currentPage: Promisable<Page>) => ClickUIElementEvent;

package/dist/types/wrapper/engagement/ui-element/types.d.ts

@@ -0,0 +1,29 @@
+import type { BaseEventExperiment, BaseEventMetrics } from '../../types/base-event.js';
+import type { EngagementEvent } from '../../types/engagement-event.js';
+import type { Layout, NavigationType, Page, Placement, Target } from '../../types/event.js';
+type ClickUIElementInputObject = {
+    id: string;
+    elementType: string;
+    name: string;
+    duration?: number;
+    layout?: Layout;
+    page?: Page;
+    placement?: Placement;
+    position?: string;
+    size?: string;
+    custom?: Record<string, unknown>;
+};
+type ClickUIElementOutputObject = {
+    navigationType: NavigationType;
+    type: 'UIElement';
+    url: string;
+} & ClickUIElementInputObject;
+type ClickUIElementInputProperties = {
+    object: ClickUIElementInputObject;
+    intent?: string;
+    target?: Target;
+    metrics?: BaseEventMetrics;
+    experiments?: BaseEventExperiment[];
+};
+type ClickUIElementEvent = EngagementEvent<ClickUIElementOutputObject>;
+export type { ClickUIElementInputObject, ClickUIElementOutputObject, ClickUIElementInputProperties, ClickUIElementEvent, };

package/dist/types/wrapper/types/base-event.d.ts

@@ -0,0 +1,74 @@
+import type { EventInput } from '../../types.js';
+import type { Promisable } from './utils.js';
+type BaseEventEventActor = {
+    id: string | number;
+    subscriptionName: string;
+    realm: string;
+};
+type BaseEventEventActorUndefined = {
+    id: undefined;
+};
+type Actor = BaseEventEventActor | BaseEventEventActorUndefined;
+export type BaseEventExperiment = {
+    id: string;
+    variant?: string;
+    name?: string;
+    platform?: string;
+    custom?: Record<string, string>;
+};
+type BaseEventOrigin = {
+    id?: string;
+    type?: string;
+    campaign?: string | Promise<string | undefined>;
+    category?: string;
+    channel?: string | Promise<string | undefined>;
+    content?: string | Promise<string | undefined>;
+    source?: string | Promise<string | undefined>;
+    url?: string;
+    terms?: string | Promise<string | undefined>;
+    xDomainId?: string | Promise<string | undefined>;
+};
+type ProductType = 'Web' | 'ResponsiveWeb' | 'AndroidApp' | 'iOSApp' | 'Other';
+type ProviderComponent = 'core-navigation' | 'hermes' | 'schibsted-account' | 'payments' | 'privacy' | 'pulse';
+type BaseEventProvider = {
+    id: string;
+    type?: string;
+    product: string;
+    productTag?: string;
+    productType: ProductType;
+    author?: string;
+    component?: ProviderComponent;
+    componentVersion?: string;
+};
+type BaseEventCustom = Record<string, unknown>;
+type BaseEventObject = {
+    id: string;
+    type?: string;
+    url?: string;
+    'spt:custom'?: Record<string, unknown>;
+};
+type BaseEventMetric = {
+    source: string;
+    name: string;
+    key: string;
+    value: string | number | boolean;
+};
+export type BaseEventMetrics = BaseEventMetric[];
+type BaseEvent<EventObject = BaseEventObject> = {
+    actor?: Promisable<Actor>;
+    experiments?: Promisable<BaseEventExperiment[]>;
+    object: Promisable<EventObject>;
+    provider?: Promisable<BaseEventProvider>;
+    origin?: Promisable<BaseEventOrigin>;
+    metrics?: Promisable<BaseEventMetrics>;
+    deployStage?: Promisable<string>;
+    deployTag?: Promisable<string>;
+} & EventInput;
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+type PromisableExperiments = Promisable<BaseEventExperiment[]> | Array<Promisable<BaseEventExperiment>>;
+type EventProperties = DeepPartial<Omit<BaseEvent, 'experiments'>> & {
+    experiments?: PromisableExperiments;
+};
+export type { BaseEvent, BaseEventObject, BaseEventCustom, BaseEventProvider, BaseEventOrigin, EventProperties, Actor };

package/dist/types/wrapper/types/engagement-event.d.ts

@@ -0,0 +1,5 @@
+import type { BaseEvent, BaseEventObject } from './base-event.js';
+export type EngagementEvent<EventObject = BaseEventObject> = BaseEvent<EventObject> & {
+    action?: 'Click' | 'Zoom' | 'Pinch' | 'Swipe' | 'Drag' | 'Drop' | 'Spin' | 'Scroll';
+    type: 'Engagement';
+};

package/dist/types/wrapper/types/event.d.ts

@@ -0,0 +1,41 @@
+type NavigationType = 'navigation' | 'alternative' | 'refresh' | 'unknown';
+type PageType = 'Article' | 'Listing' | 'Frontpage' | 'SalesPoster' | 'Page' | 'LoginPoster';
+type TargetCategory = 'Article' | 'Audio' | 'Video' | 'Weather' | 'Title' | 'other';
+type TargetType = 'Article' | 'ArticleReference' | 'ExternalContent';
+type SalesPosterType = 'Ip' | 'Login' | 'Paid' | 'Meter' | 'Personalised';
+type Page = {
+    id: string;
+    type: PageType;
+    url?: string;
+};
+type AccessLevel = 'Paid' | 'Free' | 'Meter' | 'Login';
+type Layout = {
+    elementSize?: string;
+    imageUrl?: string;
+    name?: string;
+};
+type Placement = {
+    primaryPosition?: number;
+    secondaryPosition?: number;
+    positionInBundle?: number;
+    columnName?: string;
+    curateContext?: string;
+    source?: string;
+};
+type Target = {
+    url: string;
+} | {
+    url: string;
+    id: string;
+    type: string;
+} | {
+    id: string;
+    type: TargetType;
+    category?: TargetCategory;
+    name: string;
+    url: string;
+    accessLevel?: AccessLevel;
+    accessLevelName?: string;
+    newsroom?: string;
+};
+export type { NavigationType, SalesPosterType, Page, PageType, AccessLevel, Layout, Placement, Target, TargetCategory, TargetType, };

package/dist/types/wrapper/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base-event.js';
+export * from './event.js';
+export * from './utils.js';

package/dist/types/wrapper/types/utils.d.ts

@@ -0,0 +1,5 @@
+type Promisable<T> = T | Promise<T>;
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type { Promisable, DeepPartial };

package/dist/types/wrapper/utils/get-navigation-type.d.ts

@@ -0,0 +1,3 @@
+import type { NavigationType } from '../types/event.js';
+declare const getNavigationType: () => NavigationType;
+export { getNavigationType };

package/dist/types/wrapper/utils/page-from-page-view.d.ts

@@ -0,0 +1,3 @@
+import type { BaseEvent, Page, Promisable } from '../types/index.js';
+declare const pageFromPageView: (pageView: BaseEvent) => Promisable<Page>;
+export { pageFromPageView };

package/dist/types/wrapper/view/article/event-builder.d.ts

@@ -0,0 +1,2 @@
+import type { ViewArticleEvent, ViewArticleInputProperties } from './types.js';
+export declare const buildLegacyViewArticleEvent: (inputProperties: ViewArticleInputProperties) => ViewArticleEvent;

package/dist/types/wrapper/view/article/types.d.ts

@@ -0,0 +1,27 @@
+import type { BaseEvent } from '../../types/base-event.js';
+import type { AccessLevel, NavigationType, Page } from '../../types/event.js';
+type ViewArticleInputObject = {
+    articleId: string;
+    accessLevel: AccessLevel;
+    accessLevelName: string;
+    authors: string[];
+    category: string;
+    name: string;
+    tags: string[];
+    wordCount: number;
+    group?: 'news' | 'sports';
+    page?: Page;
+    updated?: string;
+    imageUrl?: string;
+    'spt:custom'?: Record<string, unknown>;
+};
+type ViewArticleOutputObject = {
+    id: string;
+    navigationType: NavigationType;
+    type: 'Article';
+    contentId: string;
+    url: string;
+} & Omit<ViewArticleInputObject, 'articleId'>;
+type ViewArticleInputProperties = BaseEvent<ViewArticleInputObject>;
+type ViewArticleEvent = BaseEvent<ViewArticleOutputObject>;
+export type { ViewArticleInputObject, ViewArticleOutputObject, ViewArticleInputProperties, ViewArticleEvent };

package/dist/types/wrapper/view/frontpage/event-builder.d.ts

@@ -0,0 +1,2 @@
+import type { ViewFrontpageEvent, ViewFrontpageInputProperties } from './types.js';
+export declare const buildLegacyViewFrontpageEvent: (inputProperties: ViewFrontpageInputProperties) => ViewFrontpageEvent;

package/dist/types/wrapper/view/frontpage/types.d.ts

@@ -0,0 +1,18 @@
+import type { BaseEvent } from '../../types/base-event.js';
+import type { NavigationType, Page, PageType } from '../../types/event.js';
+type ViewFrontpageInputObject = {
+    id: string;
+    name: string;
+    page?: Page;
+    pageType?: PageType;
+    category?: string;
+    'spt:custom'?: Record<string, unknown>;
+};
+type ViewFrontpageOutputObject = {
+    navigationType: NavigationType;
+    type: 'Frontpage';
+    url: string;
+} & ViewFrontpageInputObject;
+type ViewFrontpageInputProperties = BaseEvent<ViewFrontpageInputObject>;
+type ViewFrontpageEvent = BaseEvent<ViewFrontpageOutputObject>;
+export type { ViewFrontpageInputObject, ViewFrontpageOutputObject, ViewFrontpageInputProperties, ViewFrontpageEvent };

package/dist/types/wrapper/view/listing/event-builder.d.ts

@@ -0,0 +1,2 @@
+import type { ViewListingEvent, ViewListingInputProperties } from './types.js';
+export declare const buildLegacyViewListingEvent: (inputProperties: ViewListingInputProperties) => ViewListingEvent;

package/dist/types/wrapper/view/listing/types.d.ts

@@ -0,0 +1,27 @@
+import type { BaseEvent } from '../../types/base-event.js';
+import type { NavigationType, Page } from '../../types/event.js';
+type AutoComplete = {
+    chosenIndex: number;
+    input: string;
+    suggestionCategory: string;
+    suggestions: string[];
+};
+type ViewListingInputObject = {
+    id: string;
+    name: string;
+    autoComplete?: AutoComplete;
+    category?: string;
+    listingType?: string;
+    numItems?: number;
+    page?: Page;
+    pageNumber?: number;
+    'spt:custom'?: Record<string, unknown>;
+};
+type ViewListingOutputObject = {
+    navigationType: NavigationType;
+    type: 'Listing';
+    url: string;
+} & ViewListingInputObject;
+type ViewListingInputProperties = BaseEvent<ViewListingInputObject>;
+type ViewListingEvent = BaseEvent<ViewListingOutputObject>;
+export type { ViewListingInputObject, ViewListingOutputObject, ViewListingInputProperties, ViewListingEvent };

package/dist/types/wrapper/view/loginposter/event-builder.d.ts

@@ -0,0 +1,2 @@
+import type { ViewLoginPosterEvent, ViewLoginPosterInputProperties } from './types.js';
+export declare const buildViewLoginPosterEvent: (inputProperties: ViewLoginPosterInputProperties) => ViewLoginPosterEvent;

package/dist/types/wrapper/view/loginposter/types.d.ts

@@ -0,0 +1,14 @@
+import type { BaseEvent } from '../../types/base-event.js';
+type LoginMethod = 'magiclink' | 'embedded-schibsted-account' | 'link-to-schibsted-account';
+type ViewLoginPosterInputObject = {
+    id: string;
+    name: string;
+    loginMethod: LoginMethod;
+    'spt:custom'?: Record<string, unknown>;
+};
+type ViewLoginPosterOutputObject = {
+    type: 'LoginPoster';
+} & ViewLoginPosterInputObject;
+type ViewLoginPosterInputProperties = BaseEvent<ViewLoginPosterInputObject>;
+type ViewLoginPosterEvent = BaseEvent<ViewLoginPosterOutputObject>;
+export type { ViewLoginPosterInputObject, ViewLoginPosterOutputObject, ViewLoginPosterInputProperties, ViewLoginPosterEvent, };

package/dist/types/wrapper/view/page/event-builder.d.ts

@@ -0,0 +1,2 @@
+import type { ViewPageEvent, ViewPageInputProperties } from './types.js';
+export declare const buildLegacyViewPageEvent: (inputProperties: ViewPageInputProperties) => ViewPageEvent;

package/dist/types/wrapper/view/page/types.d.ts

@@ -0,0 +1,16 @@
+import type { BaseEvent } from '../../types/base-event.js';
+import type { NavigationType } from '../../types/event.js';
+type ViewPageInputObject = {
+    pageId: string;
+    name: string;
+    'spt:custom'?: Record<string, unknown>;
+};
+type ViewPageOutputObject = {
+    id: string;
+    navigationType: NavigationType;
+    type: 'Page';
+    url: string;
+} & Omit<ViewPageInputObject, 'pageId'>;
+type ViewPageInputProperties = BaseEvent<ViewPageInputObject>;
+type ViewPageEvent = BaseEvent<ViewPageOutputObject>;
+export type { ViewPageInputObject, ViewPageOutputObject, ViewPageInputProperties, ViewPageEvent };

package/dist/types/wrapper/view/salesposter/event-builder.d.ts

@@ -0,0 +1,2 @@
+import type { ViewSalesPosterEvent, ViewSalesPosterInputProperties } from './types.js';
+export declare const buildViewSalesPosterEvent: (inputProperties: ViewSalesPosterInputProperties) => ViewSalesPosterEvent;

package/dist/types/wrapper/view/salesposter/types.d.ts

@@ -0,0 +1,15 @@
+import type { BaseEvent } from '../../types/base-event.js';
+import type { NavigationType, SalesPosterType } from '../../types/event.js';
+import type { ViewArticleInputObject } from '../article/types.js';
+type ViewSalesPosterInputObject = ViewArticleInputObject & {
+    salesPosterType: SalesPosterType;
+};
+type ViewSalesPosterOutputObject = {
+    id: string;
+    navigationType: NavigationType;
+    type: 'SalesPoster';
+    url: string;
+} & Omit<ViewSalesPosterInputObject, 'articleId'>;
+type ViewSalesPosterInputProperties = BaseEvent<ViewSalesPosterInputObject>;
+type ViewSalesPosterEvent = BaseEvent<ViewSalesPosterOutputObject>;
+export type { ViewSalesPosterInputObject, ViewSalesPosterOutputObject, ViewSalesPosterInputProperties, ViewSalesPosterEvent, };

package/dist/types/wrapper/view/ui-element/event-builder.d.ts

@@ -0,0 +1,3 @@
+import type { Page, Promisable } from '../../types/index.js';
+import type { ViewUIElementEvent, ViewUIElementInputProperties } from './types.js';
+export declare const buildLegacyViewUIElementEvent: (inputProperties: ViewUIElementInputProperties, currentPage: Promisable<Page>) => ViewUIElementEvent;