@rokt/dcui-orchestrator 0.0.2-rc.0

package/node_modules/@rokt/plugin/interface/basic-object.d.ts

@@ -0,0 +1,6 @@
+export type BasicType = string | number | boolean | undefined | void;
+export type BasicArray = Array<BasicType> | Array<BasicObject> | Array<BasicArray>;
+export type BasicObject = {
+    [key: string]: BasicType | BasicObject | Array<BasicObject> | Array<BasicType>;
+};
+export type BasicObjectArray = BasicObject | BasicArray;

package/node_modules/@rokt/plugin/interface/basic-object.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/child-plugin-factory.d.ts

@@ -0,0 +1,10 @@
+import { BasicObject } from './basic-object';
+import { ChildPluginInterface } from './child-plugin';
+export type CreateChildPluginOptions = {
+    url?: string;
+    name?: string;
+    config?: BasicObject;
+};
+export interface ChildPluginFactoryInterface {
+    create<T extends BasicObject>(options: CreateChildPluginOptions): ChildPluginInterface<T>;
+}

package/node_modules/@rokt/plugin/interface/child-plugin-factory.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/child-plugin.d.ts

@@ -0,0 +1,6 @@
+import { SenderReceiver } from './sender-receiver';
+export interface ChildPluginInterface<T> extends SenderReceiver {
+    close(): Promise<void>;
+    onClose(): Promise<void>;
+    putConfig(config: T): Promise<void>;
+}

package/node_modules/@rokt/plugin/interface/child-plugin.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/context.d.ts

@@ -0,0 +1,19 @@
+export interface ContextInterface {
+    getRuntimeInitTime(): Promise<Date>;
+    getParentInstanceId(): Promise<string | undefined>;
+    getRoktPageInstanceGuid(): Promise<string>;
+    getAlias(): Promise<string>;
+    getLauncherInstanceId(): Promise<string>;
+    getPluginInstanceId(): Promise<string>;
+    getRoktAccountId(): Promise<string>;
+    getRoktTagId(): Promise<string>;
+    getRoktSessionId(): Promise<string>;
+    getLanguage(): Promise<string>;
+    isSandboxed(): Promise<boolean>;
+    isChildPlugin(): Promise<boolean>;
+    isPlugin(): Promise<boolean>;
+    close(): Promise<void>;
+    addAdvertiserWindowRef(windowRef: Window | undefined, parentGuid: string): void;
+    getApiUrl(): Promise<string>;
+    getOverrideLinkNavigation(): boolean;
+}

package/node_modules/@rokt/plugin/interface/context.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/display.d.ts

@@ -0,0 +1,24 @@
+import { Subscriber } from './subscriber';
+export type DisplayPreset = (typeof DisplayPreset)[keyof typeof DisplayPreset];
+export declare const DisplayPreset: {
+    readonly FULLSCREEN: "DisplayPreset.FULLSCREEN";
+    readonly EMBEDDED: "DisplayPreset.EMBEDDED";
+    readonly ATTACHED: "DisplayPreset.ATTACHED";
+};
+export type SandboxAttribute = 'allow-forms' | 'allow-modals' | 'allow-orientation-lock' | 'allow-pointer-lock' | 'allow-popups' | 'allow-popups-to-escape-sandbox' | 'allow-presentation' | 'allow-same-origin' | 'allow-scripts' | 'allow-top-navigation' | 'allow-top-navigation-by-user-activation';
+export type DisplaySettings = {
+    preset?: DisplayPreset;
+    autoresize?: boolean;
+    applyHighestZIndex?: boolean;
+    sandbox?: Array<SandboxAttribute>;
+    replaceUrl?: string;
+    replaceTargetElement?: string;
+    css?: Record<string, any>;
+    innerCss?: Record<string, any>;
+    outerCss?: Record<string, any>;
+    title?: string;
+};
+export interface DisplayInterface {
+    settings: Subscriber<DisplaySettings | undefined>;
+    setDisplaySettings(settings?: DisplaySettings): Promise<void>;
+}

package/node_modules/@rokt/plugin/interface/display.js

@@ -0,0 +1,5 @@
+export const DisplayPreset = {
+    FULLSCREEN: 'DisplayPreset.FULLSCREEN',
+    EMBEDDED: 'DisplayPreset.EMBEDDED',
+    ATTACHED: 'DisplayPreset.ATTACHED',
+};

package/node_modules/@rokt/plugin/interface/error.d.ts

@@ -0,0 +1,15 @@
+export type ErrorLevel = (typeof ErrorLevel)[keyof typeof ErrorLevel];
+export declare const ErrorLevel: {
+    readonly ERROR: "ERROR";
+    readonly INFO: "INFO";
+    readonly WARNING: "WARNING";
+};
+export type RaiseErrorOptions = {
+    level: ErrorLevel;
+    code?: string;
+    message?: string;
+    additionalInformation?: Record<string, any>;
+};
+export interface ErrorInterface {
+    raise(options: RaiseErrorOptions): Promise<void>;
+}

package/node_modules/@rokt/plugin/interface/error.js

@@ -0,0 +1,5 @@
+export const ErrorLevel = {
+    ERROR: 'ERROR',
+    INFO: 'INFO',
+    WARNING: 'WARNING',
+};

package/node_modules/@rokt/plugin/interface/index.d.ts

@@ -0,0 +1,16 @@
+export * from './attributes';
+export * from './basic-object';
+export * from './child-plugin';
+export * from './child-plugin-factory';
+export * from './context';
+export * from './display';
+export * from './error';
+export * from './metrics';
+export * from './parent-interaction';
+export * from './partner-interaction';
+export * from './plugin-config';
+export * from './plugin-interface';
+export * from './rdn';
+export * from './sender-receiver';
+export * from './theme';
+export * from './unsafe';

package/node_modules/@rokt/plugin/interface/index.js

@@ -0,0 +1,16 @@
+export * from './attributes';
+export * from './basic-object';
+export * from './child-plugin';
+export * from './child-plugin-factory';
+export * from './context';
+export * from './display';
+export * from './error';
+export * from './metrics';
+export * from './parent-interaction';
+export * from './partner-interaction';
+export * from './plugin-config';
+export * from './plugin-interface';
+export * from './rdn';
+export * from './sender-receiver';
+export * from './theme';
+export * from './unsafe';

package/node_modules/@rokt/plugin/interface/metrics.d.ts

@@ -0,0 +1,36 @@
+export type MetricEventOptions = {
+    timestamp?: Date;
+    data?: Record<string, string>;
+};
+export interface MetricsInterface {
+    /**
+     * Notifies WSDK that the plugin has become interactive. This is used for WSDK
+     * metric reporting, and is expected that the plugin developer calls this manually
+     * when a web plugin becomes interactive which is defined as:
+     * 1. The plugin has displayed useful content
+     * 2. User can interact with the content (e.g. event handlers are registered for visible page elements)
+     */
+    notifyInteractive(): Promise<void>;
+    /**
+     * Log will allow you to log your performance metrics straight to DataDog.
+     * The metricName, should be a simple name associated to your metric.
+     *
+     * Important, the chosen name needs to be whitelisted in the rokt-widget-api first.
+     *
+     * All other facets, such as:
+     * - Plugin
+     * - TagId
+     * - Integration
+     * - PageId
+     * are automatically added to this metric.
+     *
+     * @param metricName
+     * @param duration
+     */
+    log(metricName: string, duration: number): Promise<void>;
+    /**
+     * Helper method for accessing the timestamp of the plugin iframe creation.
+     * Useful if you need to report any metrics based of this value.
+     */
+    getFrameStart(): Promise<Date>;
+}

package/node_modules/@rokt/plugin/interface/metrics.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/parent-interaction.d.ts

@@ -0,0 +1,2 @@
+import { SenderReceiver } from './sender-receiver';
+export type ParentInteractionInterface = SenderReceiver;

package/node_modules/@rokt/plugin/interface/parent-interaction.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/partner-interaction.d.ts

@@ -0,0 +1,6 @@
+import { SenderReceiver } from './sender-receiver';
+export type FulfillmentAttribute = {
+    name: string;
+    value: string;
+};
+export type PartnerInteractionInterface = SenderReceiver;

package/node_modules/@rokt/plugin/interface/partner-interaction.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/plugin-config.d.ts

@@ -0,0 +1,14 @@
+import { NormalizedAttributes } from './attributes';
+import { DisplaySettings } from './display';
+export type PluginConfig<T = any> = {
+    config: T;
+    display?: DisplaySettings;
+    configurables: Record<string, string>;
+    fonts: Array<{
+        fontFamily: string;
+        fontStyle: string;
+        fontWeight: string;
+        src: Array<string>;
+    }>;
+    attributes: NormalizedAttributes;
+};

package/node_modules/@rokt/plugin/interface/plugin-config.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/plugin-interface.d.ts

@@ -0,0 +1,26 @@
+import { Subscriber } from './subscriber';
+import { ContextInterface } from './context';
+import { ParentInteractionInterface } from './parent-interaction';
+import { PartnerInteractionInterface } from './partner-interaction';
+import { RDNInterface } from './rdn';
+import { MetricsInterface } from './metrics';
+import { ErrorInterface } from './error';
+import { UnsafeInterface } from './unsafe';
+import { DisplayInterface } from './display';
+import { ThemeInterface } from './theme';
+import { ChildPluginFactoryInterface } from './child-plugin-factory';
+import { NormalizedAttributes } from './attributes';
+export type PluginInterface<T = void> = {
+    context: ContextInterface;
+    config: Subscriber<T>;
+    attributes: Subscriber<NormalizedAttributes>;
+    childPlugin: ChildPluginFactoryInterface;
+    parentInteraction: ParentInteractionInterface;
+    partnerInteraction: PartnerInteractionInterface;
+    rdn: RDNInterface;
+    metrics: MetricsInterface;
+    error: ErrorInterface;
+    theme: ThemeInterface;
+    display: DisplayInterface;
+    unsafe: UnsafeInterface;
+};

package/node_modules/@rokt/plugin/interface/plugin-interface.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/rdn.d.ts

@@ -0,0 +1,17 @@
+export type SignalAttributes = {
+    name: string;
+    value: string;
+};
+export type IssueSignalOptions = {
+    instanceGuid?: string;
+    attributes?: Array<SignalAttributes>;
+    metadata?: Array<SignalAttributes>;
+    objectData?: Record<string, string>;
+    overrideTimestamp?: Date;
+    transformedTrafficURL?: string;
+};
+export interface RDNInterface {
+    issueSignal(eventType: string, parentGuid: string, options?: IssueSignalOptions): Promise<void>;
+    issueSignalSync(eventType: string, parentGuid: string, options?: IssueSignalOptions): Promise<void>;
+    prepareExternalSignal(sendOnEvent: string, eventType: string, parentGuid: string, options?: IssueSignalOptions): Promise<void>;
+}

package/node_modules/@rokt/plugin/interface/rdn.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/sender-receiver.d.ts

@@ -0,0 +1,5 @@
+import { Subscriber } from './subscriber';
+export interface SenderReceiver {
+    send<Req = any>(eventName: string, body?: Req): Promise<void>;
+    onEvent<T = any>(eventName: string): Subscriber<T>;
+}

package/node_modules/@rokt/plugin/interface/sender-receiver.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/subscriber.d.ts

@@ -0,0 +1,14 @@
+export type Callback<T extends Array<any> = any> = (...args: T) => any | Promise<any>;
+export type NextFn<T> = (value: T) => void;
+export interface Observer<T> {
+    next: NextFn<T>;
+    error: (error?: any) => any;
+    complete: Callback<[]>;
+}
+export interface Unsubscriber {
+    unsubscribe(): void;
+}
+export interface Subscriber<T> {
+    subscribe(observer: Partial<Observer<T>>): Unsubscriber;
+    subscribe(value?: Callback<[T]>, error?: Callback<any>, complete?: Callback<[]>): Unsubscriber;
+}

package/node_modules/@rokt/plugin/interface/subscriber.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/theme.d.ts

@@ -0,0 +1,8 @@
+import { Subscriber } from './subscriber';
+import { PluginConfig } from './plugin-config';
+export type Fonts = PluginConfig['fonts'];
+export type Configurables = PluginConfig['configurables'];
+export interface ThemeInterface {
+    configurables: Subscriber<Configurables>;
+    fonts: Subscriber<Fonts>;
+}

package/node_modules/@rokt/plugin/interface/theme.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/interface/unsafe.d.ts

@@ -0,0 +1 @@
+export type UnsafeInterface = object;

package/node_modules/@rokt/plugin/interface/unsafe.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/plugin/lib/bootstrap-v1.d.ts

@@ -0,0 +1,3 @@
+import { PluginAdapterOptions } from './plugin-instance';
+import { PluginInterface } from '../interface';
+export declare const bootstrapV1: (args?: PluginAdapterOptions) => Promise<PluginInterface>;

package/node_modules/@rokt/plugin/lib/bootstrap-v1.js

@@ -0,0 +1,9 @@
+import { bootstrap } from '../bootstrap/bootstrap';
+import { PluginInstance } from './plugin-instance';
+import { inferName } from '@rokt/wsdk-integration/controller/fn/infer-name';
+export const bootstrapV1 = (args = { targetWindow: window }) => {
+    if (args.targetWindow.name.includes('integration_type=plugin')) {
+        return bootstrap(args);
+    }
+    return Promise.resolve(new PluginInstance(Object.assign(Object.assign({ alias: inferName(window.location.href) }, args), { pluginStartTimestampOverride: new Date() })));
+};

package/node_modules/@rokt/plugin/lib/child-plugin-factory.d.ts

@@ -0,0 +1,14 @@
+import { stream } from '@rokt/kit/stream';
+import { PluginToPluginRequest, PluginIsClosingRequest } from '@rokt/wsdk-integration/plugin';
+import { Subscriber } from '@rokt/kit/reactive';
+import { IPrivateContext } from './private-context';
+import { ChildPluginFactoryInterface, ChildPluginInterface, CreateChildPluginOptions } from '../interface';
+import { BasicObject } from '@rokt/kit/typings';
+export declare class ChildPluginFactory implements ChildPluginFactoryInterface {
+    private connection;
+    private context;
+    private pluginMessagesInbound;
+    private pluginChildIsClosing;
+    constructor(connection: stream.Sender, context: IPrivateContext, pluginMessagesInbound: Subscriber<PluginToPluginRequest>, pluginChildIsClosing: Subscriber<PluginIsClosingRequest>);
+    create<T extends BasicObject = BasicObject>(options: CreateChildPluginOptions): ChildPluginInterface<T>;
+}

package/node_modules/@rokt/plugin/lib/child-plugin-factory.js

@@ -0,0 +1,12 @@
+import { ChildPlugin } from './child-plugin';
+export class ChildPluginFactory {
+    constructor(connection, context, pluginMessagesInbound, pluginChildIsClosing) {
+        this.connection = connection;
+        this.context = context;
+        this.pluginMessagesInbound = pluginMessagesInbound;
+        this.pluginChildIsClosing = pluginChildIsClosing;
+    }
+    create(options) {
+        return new ChildPlugin(this.connection, this.context, options, this.pluginMessagesInbound, this.pluginChildIsClosing);
+    }
+}

package/node_modules/@rokt/plugin/lib/child-plugin.d.ts

@@ -0,0 +1,26 @@
+import { BasicObject } from '@rokt/kit/typings';
+import { stream } from '@rokt/kit/stream';
+import { PluginToPluginRequest, PluginIsClosingRequest } from '@rokt/wsdk-integration/plugin';
+import { Subscriber } from '@rokt/kit/reactive';
+import { IPrivateContext } from './private-context';
+import { ChildPluginInterface, CreateChildPluginOptions } from '../interface';
+export type RuntimeMessage = (typeof RuntimeMessage)[keyof typeof RuntimeMessage];
+export declare const RuntimeMessage: {
+    readonly Ready: "[runtime] READY_MESSAGE";
+};
+export declare class ChildPlugin<T extends BasicObject = BasicObject> implements ChildPluginInterface<T> {
+    private connection;
+    private context;
+    private options;
+    private pluginMessagesInbound;
+    private pluginChildIsClosing;
+    private _ready;
+    private _childInstanceId;
+    constructor(connection: stream.Sender, context: IPrivateContext, options: CreateChildPluginOptions, pluginMessagesInbound: Subscriber<PluginToPluginRequest>, pluginChildIsClosing: Subscriber<PluginIsClosingRequest>);
+    close(): Promise<void>;
+    onClose(): Promise<void>;
+    putConfig(_config: T): Promise<void>;
+    send<Req = any>(eventName: string, body?: Req): Promise<void>;
+    onEvent<U = any>(eventName: string): Subscriber<U>;
+    private _sendCreatePlugin;
+}

package/node_modules/@rokt/plugin/lib/child-plugin.js

@@ -0,0 +1,81 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { roktController } from '@rokt/wsdk-integration/controller';
+import { roktLauncher } from '@rokt/wsdk-integration/launcher';
+import { lastValueFrom, ReplaySubject } from '@rokt/kit/reactive';
+import { pipe, first, filter, map } from '@rokt/kit/reactive/operators';
+export const RuntimeMessage = {
+    Ready: '[runtime] READY_MESSAGE',
+};
+export class ChildPlugin {
+    constructor(connection, context, options, pluginMessagesInbound, pluginChildIsClosing) {
+        this.connection = connection;
+        this.context = context;
+        this.options = options;
+        this.pluginMessagesInbound = pluginMessagesInbound;
+        this.pluginChildIsClosing = pluginChildIsClosing;
+        this._childInstanceId = '';
+        this._ready = this._sendCreatePlugin();
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._ready;
+            this.connection.send(roktLauncher.MessageType.CLOSE_PLACEMENT, {
+                body: { pluginInstanceId: this._childInstanceId },
+            });
+        });
+    }
+    onClose() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield lastValueFrom(pipe(this.pluginChildIsClosing)(first((ev) => ev.pluginInstanceId === this._childInstanceId)));
+        });
+    }
+    putConfig(_config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: Alsh
+        });
+    }
+    send(eventName, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._ready;
+            yield this.connection.send(roktController.MessageType.PLUGIN_TO_PLUGIN_OUTBOUND, {
+                body: {
+                    to: this._childInstanceId,
+                    from: this.context.getPluginInstanceId(),
+                    eventName,
+                    body,
+                },
+            });
+        });
+    }
+    onEvent(eventName) {
+        return pipe(this.pluginMessagesInbound)(filter((ev) => ev.from === this._childInstanceId &&
+            Object.values(RuntimeMessage).includes(ev.eventName) === false &&
+            (ev.eventName === eventName || eventName === '*')), map((ev) => {
+            if (ev.eventName === '*') {
+                return { event: ev.eventName, body: ev.body };
+            }
+            return ev.body;
+        }));
+    }
+    _sendCreatePlugin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const buffer = new ReplaySubject();
+            const sub = this.pluginMessagesInbound.subscribe((msg) => buffer.next(msg));
+            const { body } = yield this.connection.send(roktController.MessageType.CREATE_PLUGIN, {
+                body: Object.assign({ parentInstanceId: this.context.getPluginInstanceId() }, this.options),
+            });
+            this._childInstanceId = body.pluginInstanceId;
+            const response = pipe(buffer)(first(({ eventName, from }) => eventName === RuntimeMessage.Ready && from === body.pluginInstanceId));
+            yield lastValueFrom(response);
+            sub.unsubscribe();
+        });
+    }
+}

package/node_modules/@rokt/plugin/lib/context.d.ts

@@ -0,0 +1,23 @@
+import { ContextInterface } from '../interface';
+import { IPrivateContext } from './private-context';
+export declare class Context implements ContextInterface {
+    private _privateContext;
+    constructor(_privateContext: IPrivateContext);
+    getRoktAccountId(): Promise<string>;
+    getRoktPageInstanceGuid(): Promise<string>;
+    getParentInstanceId(): Promise<string | undefined>;
+    getRuntimeInitTime(): Promise<Date>;
+    getAlias(): Promise<string>;
+    getLauncherInstanceId(): Promise<string>;
+    getPluginInstanceId(): Promise<string>;
+    getRoktTagId(): Promise<string>;
+    getRoktSessionId(): Promise<string>;
+    getLanguage(): Promise<string>;
+    isSandboxed(): Promise<boolean>;
+    isChildPlugin(): Promise<boolean>;
+    isPlugin(): Promise<boolean>;
+    close(): Promise<void>;
+    addAdvertiserWindowRef(_windowRef: Window | undefined, _parentGuid: string): void;
+    getApiUrl(): Promise<string>;
+    getOverrideLinkNavigation(): boolean;
+}

package/node_modules/@rokt/plugin/lib/context.js

@@ -0,0 +1,95 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class Context {
+    constructor(_privateContext) {
+        this._privateContext = _privateContext;
+    }
+    getRoktAccountId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.getRoktAccountId();
+        });
+    }
+    getRoktPageInstanceGuid() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.getRoktPageInstanceGuid();
+        });
+    }
+    getParentInstanceId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.getParentInstanceId();
+        });
+    }
+    getRuntimeInitTime() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.getRuntimeInitTime();
+        });
+    }
+    getAlias() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.getAlias();
+        });
+    }
+    getLauncherInstanceId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.getLauncherInstanceId();
+        });
+    }
+    getPluginInstanceId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.getPluginInstanceId();
+        });
+    }
+    getRoktTagId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.getRoktTagId();
+        });
+    }
+    getRoktSessionId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.getRoktSessionId();
+        });
+    }
+    getLanguage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.getLanguage();
+        });
+    }
+    isSandboxed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.isSandboxed();
+        });
+    }
+    isChildPlugin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.isChildPlugin();
+        });
+    }
+    isPlugin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.isPlugin();
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._privateContext.close();
+        });
+    }
+    addAdvertiserWindowRef(_windowRef, _parentGuid) {
+        // empty
+    }
+    getApiUrl() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve('');
+        });
+    }
+    getOverrideLinkNavigation() {
+        return false;
+    }
+}

package/node_modules/@rokt/plugin/lib/debug.d.ts

@@ -0,0 +1,19 @@
+import { Subject, ReplaySubject } from '@rokt/kit/reactive';
+import { PartnerMessageRequest, PluginToPluginRequest, PluginIsClosingRequest } from '@rokt/wsdk-integration/plugin';
+import { PluginConfig, NormalizedAttributes } from '../interface';
+import { stream } from '@rokt/kit/stream';
+export declare class Debug implements stream.Sender {
+    private _window;
+    identifier: string;
+    logger: (...args: Array<any>) => void;
+    readonly partnerMessages: Subject<PartnerMessageRequest>;
+    readonly pluginMessagesInbound: Subject<PluginToPluginRequest>;
+    readonly pluginChildIsClosing: Subject<PluginIsClosingRequest>;
+    readonly pluginConfig: ReplaySubject<PluginConfig>;
+    readonly attributes: ReplaySubject<NormalizedAttributes>;
+    readonly contextParams: URLSearchParams;
+    private nextResponse;
+    constructor(_window: Window, identifier: string);
+    setNextResponse(response: stream.StreamEvent): void;
+    send(event: string, req: stream.RequestContext): Promise<stream.StreamEvent<any>>;
+}