@c15t/scripts 2.0.1 → 2.2.0-canary-20260727202135

package/dist-types/{x-pixel.d.ts → vendors/ads-and-pixels/x-pixel.d.ts}

@@ -69,9 +69,23 @@ export interface XPixelEvent {
     twclid?: string;
     /**
      * Status of the conversion event
-     * @example completed
+     * Should be set to values like "started" or "completed".
+     * @example "completed"
      */
-    status?: boolean;
+    status?: 'started' | 'completed';
+    /**
+     * Email address used for user matching.
+     * The X Pixel hashes this value before transmission.
+     * @example "[email protected]"
+     */
+    email_address?: string;
+    /**
+     * Phone number used for user matching.
+     * Include country code in E.164 format (for example, +11234567890).
+     * The X Pixel hashes this value before transmission.
+     * @example "+11234567890"
+     */
+    phone_number?: string;
     /**
      * Content/products associated with the conversion event
      * @example [{content_id: 'OT001', content_name: 'bird seed', content_price: 50, num_items: 1}]
@@ -91,31 +105,31 @@ declare global {
  * No consent API — the script simply loads or doesn't based on consent.
  */
 export declare const xPixelManifest: {
-    readonly vendor: "x-pixel";
-    readonly category: "marketing";
+    readonly kind: "c15t.vendor-manifest";
+    readonly schemaVersion: 1;
+    readonly vendor: 'x-pixel';
+    readonly category: 'marketing';
     readonly bootstrap: [{
-        readonly type: "defineStubFunction";
-        readonly name: "twq";
+        readonly type: 'defineStubFunction';
+        readonly name: 'twq';
         readonly queue: {
-            readonly property: "queue";
+            readonly property: 'queue';
         };
-        readonly dispatchProperty: "exe";
+        readonly dispatchProperty: 'exe';
         readonly properties: {
-            readonly version: "1.1";
+            readonly version: '1.1';
         };
         readonly ifUndefined: true;
     }];
     readonly install: [{
-        readonly type: "callGlobal";
-        readonly global: "twq";
+        readonly type: 'callGlobal';
+        readonly global: 'twq';
         readonly args: ["config", "{{pixelId}}"];
     }, {
-        readonly type: "loadScript";
-        readonly src: "{{scriptSrc}}";
+        readonly type: 'loadScript';
+        readonly src: '{{scriptSrc}}';
         readonly async: true;
     }];
-    readonly kind: "c15t.vendor-manifest";
-    readonly schemaVersion: 1;
 };
 export interface XPixelOptions {
     /**
@@ -141,7 +155,7 @@ export interface XPixelOptions {
  * });
  * ```
  *
- * @see {@link https://ads.twitter.com/help/article/x-pixel} X Pixel documentation
+ * @see {@link https://business.x.com/en/help/campaign-measurement-and-analytics/conversion-tracking-for-websites} X conversion tracking documentation
  */
 export declare function xPixel({ pixelId, scriptSrc }: XPixelOptions): Script;
 /**
@@ -162,5 +176,8 @@ export declare function xPixel({ pixelId, scriptSrc }: XPixelOptions): Script;
  * ```
  *
  * @see {@link https://business.x.com/en/help/campaign-measurement-and-analytics/conversion-tracking-for-websites#event-types-and-parameters}
+ * @throws {Error} Throws when `window` is unavailable or `window.twq` is not a
+ * function. Ensure marketing consent is granted and the X Pixel has loaded
+ * before calling this helper.
  */
-export declare const xPixelEvent: (eventId: string, metadata?: XPixelEvent) => void | undefined;
+export declare const xPixelEvent: (eventId: string, metadata?: XPixelEvent) => void;

package/dist-types/vendors/analytics/adobe-analytics.d.ts

@@ -0,0 +1,75 @@
+import type { Script } from 'c15t';
+import { type VendorManifest } from '../../types';
+declare global {
+    interface Window {
+        adobeDataLayer?: unknown[];
+        _satellite?: Record<string, unknown>;
+    }
+}
+/**
+ * Adobe Analytics vendor manifest.
+ *
+ * Loads the Adobe Experience Platform Data Collection Tags embed script for a
+ * specific property environment. Adobe does not provide a generic public
+ * loader; each customer copies their own environment URL from Data Collection,
+ * commonly hosted at `https://assets.adobedtm.com/.../launch-*.min.js`.
+ */
+export declare const adobeAnalyticsManifest: VendorManifest;
+export interface AdobeAnalyticsOptions {
+    /**
+     * Adobe Experience Platform Data Collection web property embed URL.
+     *
+     * This must be the full `https:` URL from your Adobe Tags environment embed
+     * code, commonly shaped like
+     * `https://assets.adobedtm.com/{org}/{property}/launch-{env}.min.js`.
+     * Self-hosted Launch/Tags embeds are supported as long as they use `https:`.
+     */
+    scriptUrl: string;
+    /**
+     * Load the Adobe Tags library asynchronously.
+     *
+     * Adobe recommends asynchronous deployment for most web properties. Set this
+     * to `false` only for legacy synchronous setups that require ordered blocking
+     * behavior.
+     * @default true
+     */
+    async?: boolean;
+    /**
+     * Seed the Adobe Client Data Layer queue before the Tags library loads.
+     *
+     * When enabled, c15t creates `window.adobeDataLayer = []` only when the
+     * global is still undefined. This matches Adobe Client Data Layer's default
+     * object name and is harmless for properties that do not use the extension.
+     * @default true
+     */
+    seedAdobeDataLayer?: boolean;
+}
+/**
+ * Creates an Adobe Analytics script.
+ *
+ * @see https://experienceleague.adobe.com/en/docs/experience-platform/tags/publish/environments/environments
+ * @see https://experienceleague.adobe.com/en/docs/experience-platform/tags/extensions/client/client-data-layer/overview
+ *
+ * @param options - The options for the Adobe Analytics script.
+ * @returns The Adobe Analytics script.
+ * @throws {Error} When `scriptUrl` is missing, empty, invalid, or not `https:`.
+ * Copy the full web property embed URL from Adobe Data Collection and pass it
+ * as `scriptUrl`.
+ *
+ * @remarks
+ * Adobe Analytics is commonly deployed through Adobe Experience Platform Data
+ * Collection Tags (formerly Launch). The loaded property may in turn load Adobe
+ * Analytics, Web SDK, or other extensions and rules, so configure those Adobe
+ * rules to respect your consent model too.
+ *
+ * @example
+ * ```ts
+ * import { adobeAnalytics } from '@c15t/scripts/adobe-analytics';
+ *
+ * adobeAnalytics({
+ *   scriptUrl:
+ *     'https://assets.adobedtm.com/YOUR_ORG/YOUR_PROPERTY/launch-production.min.js',
+ * });
+ * ```
+ */
+export declare function adobeAnalytics(options: AdobeAnalyticsOptions): Script;

package/dist-types/vendors/analytics/ahrefs-analytics.d.ts

@@ -0,0 +1,62 @@
+import type { Script } from 'c15t';
+declare global {
+    interface Window {
+        AhrefsAnalytics?: {
+            sendEvent: (name: string, options?: {
+                props?: Record<string, string>;
+                meta?: Record<string, unknown>;
+            }) => void;
+        };
+    }
+}
+/**
+ * Ahrefs Analytics vendor manifest.
+ *
+ * Loads Ahrefs Web Analytics and passes the project key via `data-key`. Ahrefs
+ * Web Analytics is cookieless, so the script is consent-gated on `measurement`
+ * and unloaded when consent is revoked.
+ */
+export declare const ahrefsAnalyticsManifest: {
+    readonly kind: "c15t.vendor-manifest";
+    readonly schemaVersion: 1;
+    readonly vendor: 'ahrefs-analytics';
+    readonly category: 'measurement';
+    readonly install: [{
+        readonly type: 'loadScript';
+        readonly src: '{{scriptUrl}}';
+        readonly async: true;
+        readonly attributes: {
+            readonly 'data-key': '{{key}}';
+        };
+    }];
+};
+export interface AhrefsAnalyticsOptions {
+    /**
+     * Your Ahrefs Web Analytics project key.
+     */
+    key: string;
+    /**
+     * Custom loader URL.
+     * @default 'https://analytics.ahrefs.com/analytics.js'
+     */
+    scriptUrl?: string;
+}
+/**
+ * Creates an Ahrefs Analytics script.
+ *
+ * The Ahrefs SDK exposes its runtime API on `window.AhrefsAnalytics` after
+ * load. This helper only models the serializable script manifest.
+ *
+ * @see https://ahrefs.com/web-analytics
+ *
+ * @param options - The options for the Ahrefs Analytics script.
+ * @returns The Ahrefs Analytics script.
+ *
+ * @example
+ * ```ts
+ * import { ahrefsAnalytics } from '@c15t/scripts/ahrefs-analytics';
+ *
+ * ahrefsAnalytics({ key: 'YOUR_PROJECT_KEY' });
+ * ```
+ */
+export declare function ahrefsAnalytics(options: AhrefsAnalyticsOptions): Script;

package/dist-types/vendors/analytics/amplitude.d.ts

@@ -0,0 +1,234 @@
+import type { Script } from 'c15t';
+/**
+ * Browser SDK 2 version used by the default Amplitude CDN loader URL.
+ *
+ * The Amplitude Browser SDK 2 public bundle path is versioned. A
+ * `analytics-browser-latest-min.js.gz` path is not publicly available, so c15t
+ * pins a known Browser SDK 2 version by default and lets callers override the
+ * loader through `scriptUrl`.
+ */
+export declare const DEFAULT_AMPLITUDE_BROWSER_SDK_VERSION = "2.44.4";
+/**
+ * Default Amplitude Browser SDK 2 loader URL.
+ */
+export declare const DEFAULT_AMPLITUDE_SCRIPT_URL = "https://cdn.amplitude.com/libs/analytics-browser-2.44.4-min.js.gz";
+/**
+ * Core Amplitude Browser SDK 2 methods queued before the real SDK loads.
+ *
+ * These methods use Amplitude's Browser SDK 2 snippet queue contract:
+ * `window.amplitude._q` receives `{ name, args, resolve }` records, and the
+ * loaded SDK drains that queue when `window.amplitude.invoked` is true.
+ */
+export declare const AMPLITUDE_PROMISE_QUEUE_METHODS: readonly ['init', 'track', 'identify', 'flush'];
+/**
+ * Queue methods Amplitude's snippet treats as synchronous — they queue the
+ * call but return nothing.
+ */
+export declare const AMPLITUDE_SYNC_QUEUE_METHODS: readonly ['setUserId', 'setOptOut'];
+export declare const AMPLITUDE_QUEUE_METHODS: readonly ["init", "track", "identify", "flush", "setUserId", "setOptOut"];
+/**
+ * Amplitude Identify helper methods queued before the real SDK loads.
+ */
+export declare const AMPLITUDE_IDENTIFY_METHODS: readonly ['set', 'setOnce', 'add', 'append', 'prepend', 'preInsert', 'postInsert', 'remove', 'unset', 'clearAll', 'getUserProperties'];
+/**
+ * Queue entry consumed by Amplitude Browser SDK 2 at load time.
+ */
+export interface AmplitudeQueueEntry {
+    /** Name of the Amplitude method to invoke after the SDK loads. */
+    name: (typeof AMPLITUDE_QUEUE_METHODS)[number];
+    /** Arguments originally passed to the queued method. */
+    args: unknown[];
+    /** Promise resolver called by the SDK after the queued method runs. */
+    resolve: (value: unknown) => void;
+}
+/**
+ * Queue entry stored by an Amplitude Identify helper created before load.
+ */
+export interface AmplitudeIdentifyQueueEntry {
+    /** Identify helper method to replay after the SDK loads. */
+    name: (typeof AMPLITUDE_IDENTIFY_METHODS)[number];
+    /** Arguments originally passed to the helper method. */
+    args: unknown[];
+}
+/**
+ * Pre-load Amplitude Identify helper.
+ */
+export interface AmplitudeIdentify {
+    /** Queued Identify helper operations. */
+    _q?: AmplitudeIdentifyQueueEntry[];
+    /** Queue a `$set` identify operation. */
+    set: (property: string, value: unknown) => this;
+    /** Queue a `$setOnce` identify operation. */
+    setOnce: (property: string, value: unknown) => this;
+    /** Queue an `$add` identify operation. */
+    add: (property: string, value: number) => this;
+    /** Queue an `$append` identify operation. */
+    append: (property: string, value: unknown) => this;
+    /** Queue a `$prepend` identify operation. */
+    prepend: (property: string, value: unknown) => this;
+    /** Queue a `$preInsert` identify operation. */
+    preInsert: (property: string, value: unknown) => this;
+    /** Queue a `$postInsert` identify operation. */
+    postInsert: (property: string, value: unknown) => this;
+    /** Queue a `$remove` identify operation. */
+    remove: (property: string, value: unknown) => this;
+    /** Queue an `$unset` identify operation. */
+    unset: (property: string) => this;
+    /** Queue a `$clearAll` identify operation. */
+    clearAll: () => this;
+    /** Queue a read of the accumulated user property operations. */
+    getUserProperties: () => this;
+}
+/**
+ * Minimal public Amplitude Browser SDK 2 API exposed on `window.amplitude`.
+ *
+ * The real SDK replaces the pre-load stub with these methods after the loader
+ * executes. Calls made before load return promises that resolve once the SDK
+ * replays them.
+ */
+export interface AmplitudeApi {
+    /** Amplitude Browser SDK 2 pre-load queue. */
+    _q?: AmplitudeQueueEntry[];
+    /** Named-instance queue registry used by the official snippet contract. */
+    _iq?: Record<string, unknown>;
+    /** Marker that tells the SDK to replay snippet-queued calls. */
+    invoked?: boolean;
+    /** Pre-load Identify helper constructor. */
+    Identify?: new () => AmplitudeIdentify;
+    /** Initialize the default Amplitude instance. */
+    init: (apiKey: string, options?: Record<string, unknown>) => Promise<unknown> | unknown;
+    /** Track an event with optional event properties. */
+    track: (eventInput: string | Record<string, unknown>, eventProperties?: Record<string, unknown>) => Promise<unknown> | unknown;
+    /** Send an identify call. */
+    identify: (identifyPayload: AmplitudeIdentify, eventOptions?: Record<string, unknown>) => Promise<unknown> | unknown;
+    /** Set the current user identifier. */
+    setUserId: (userId: string | undefined) => Promise<unknown> | unknown;
+    /** Toggle runtime opt-out. */
+    setOptOut: (optOut: boolean) => Promise<unknown> | unknown;
+    /** Flush pending events. */
+    flush: () => Promise<unknown> | unknown;
+}
+declare global {
+    interface Window {
+        amplitude?: AmplitudeApi;
+    }
+}
+/**
+ * Amplitude vendor manifest.
+ *
+ * Implements the essential Browser SDK 2 script-loader contract with
+ * `window.amplitude.invoked`, an `_q` method-call queue, and an `_iq` registry
+ * for named instances. It also defines the `Identify` queued helper used by
+ * pre-load `identify()` calls. c15t gates the loader on `measurement` consent,
+ * queues `init(apiKey, initOptions)` before the bundle loads, and uses
+ * `setOptOut(false)` / `setOptOut(true)` for runtime consent changes after the
+ * SDK has loaded.
+ */
+export declare const amplitudeManifest: {
+    readonly kind: "c15t.vendor-manifest";
+    readonly schemaVersion: 1;
+    readonly vendor: 'amplitude';
+    readonly category: 'measurement';
+    readonly install: [{
+        readonly type: 'setGlobal';
+        readonly name: 'amplitude';
+        readonly value: {
+            readonly _q: readonly [];
+            readonly _iq: {};
+            readonly invoked: true;
+        };
+        readonly ifUndefined: true;
+    }, {
+        readonly type: 'defineQueueClass';
+        readonly target: 'amplitude';
+        readonly name: 'Identify';
+        readonly queueProperty: '_q';
+        readonly methods: ["set", "setOnce", "add", "append", "prepend", "preInsert", "postInsert", "remove", "unset", "clearAll", "getUserProperties"];
+    }, {
+        readonly type: 'defineQueueMethods';
+        readonly target: 'amplitude';
+        readonly queue: {
+            readonly property: '_q';
+        };
+        readonly queueFormat: 'wrappedMethodCall';
+        readonly methods: ["init", "track", "identify", "flush"];
+    }, {
+        readonly type: 'defineQueueMethods';
+        readonly target: 'amplitude';
+        readonly queue: {
+            readonly property: '_q';
+        };
+        readonly queueFormat: 'voidMethodCall';
+        readonly methods: ["setUserId", "setOptOut"];
+    }, {
+        readonly type: 'callGlobal';
+        readonly global: 'amplitude';
+        readonly method: 'init';
+        readonly args: ["{{apiKey}}", "{{initOptions}}"];
+    }, {
+        readonly type: 'loadScript';
+        readonly src: '{{scriptUrl}}';
+        readonly async: true;
+    }];
+    readonly onLoadDenied: [{
+        readonly type: 'callGlobal';
+        readonly global: 'amplitude';
+        readonly method: 'setOptOut';
+        readonly args: [true];
+    }];
+    readonly onConsentGranted: [{
+        readonly type: 'callGlobal';
+        readonly global: 'amplitude';
+        readonly method: 'setOptOut';
+        readonly args: [false];
+    }];
+    readonly onConsentDenied: [{
+        readonly type: 'callGlobal';
+        readonly global: 'amplitude';
+        readonly method: 'setOptOut';
+        readonly args: [true];
+    }];
+};
+export interface AmplitudeOptions {
+    /** Amplitude project API key. */
+    apiKey: string;
+    /**
+     * Amplitude Browser SDK 2 initialization options.
+     *
+     * Values are serialized into the manifest, so use JSON-serializable values
+     * only: plain objects, arrays, strings, numbers, booleans, and `null`.
+     */
+    initOptions?: Record<string, unknown>;
+    /**
+     * Optional Amplitude loader URL override.
+     *
+     * @default 'https://cdn.amplitude.com/libs/analytics-browser-2.44.4-min.js.gz'
+     */
+    scriptUrl?: string;
+}
+/**
+ * Creates an Amplitude Browser SDK 2 script.
+ *
+ * @param options - The options for the Amplitude script.
+ * @returns The Amplitude script configuration.
+ * @throws {Error} When `apiKey` is missing or only whitespace.
+ *
+ * @remarks
+ * The generated script is gated on `measurement` consent. It does not load the
+ * Amplitude SDK until measurement consent is granted; after the SDK is loaded,
+ * later consent changes call `amplitude.setOptOut(false)` or
+ * `amplitude.setOptOut(true)`.
+ *
+ * @example
+ * ```ts
+ * import { amplitude } from '@c15t/scripts/amplitude';
+ *
+ * const script = amplitude({
+ * 	apiKey: 'AMPLITUDE_API_KEY',
+ * 	initOptions: {
+ * 		autocapture: false,
+ * 	},
+ * });
+ * ```
+ */
+export declare function amplitude({ apiKey, initOptions, scriptUrl, }: AmplitudeOptions): Script;

package/dist-types/vendors/analytics/clearbit.d.ts

@@ -0,0 +1,60 @@
+import type { Script } from 'c15t';
+/**
+ * Clearbit vendor manifest.
+ *
+ * Loads Clearbit's visitor and company enrichment tag from the account-keyed
+ * `tags.js` endpoint. Clearbit enrichment can identify visitors and companies,
+ * so the default consent category is `marketing` rather than `measurement`.
+ * The GitHub issue left the category open between measurement and marketing;
+ * c15t treats enrichment and intent profiling as marketing-sensitive.
+ */
+export declare const clearbitManifest: {
+    readonly kind: "c15t.vendor-manifest";
+    readonly schemaVersion: 1;
+    readonly vendor: 'clearbit';
+    readonly category: 'marketing';
+    readonly install: [{
+        readonly type: 'loadScript';
+        readonly src: '{{scriptUrl}}';
+        readonly attributes: {
+            readonly referrerpolicy: 'strict-origin-when-cross-origin';
+        };
+    }];
+};
+export interface ClearbitOptions {
+    /**
+     * Your Clearbit publishable key.
+     */
+    publishableKey: string;
+    /**
+     * Custom loader URL.
+     * @default `https://tag.clearbitscripts.com/v1/{publishableKey}/tags.js`
+     */
+    scriptUrl?: string;
+}
+/**
+ * Creates a Clearbit enrichment script.
+ *
+ * @see https://help.clearbit.com/hc/en-us/articles/4420022080783 — installing the Clearbit tag
+ *
+ * @param options - The options for the Clearbit script.
+ * @returns The Clearbit script.
+ * @throws {Error} When `publishableKey` is missing, empty, or invalid.
+ * Provide a valid non-empty `publishableKey` string to prevent this error.
+ *
+ * @remarks
+ * Clearbit identifies visitors and companies for enrichment and intent use
+ * cases. This helper therefore uses the `marketing` consent category by
+ * default even though Clearbit is listed with analytics integrations for
+ * discovery.
+ *
+ * @example
+ * ```ts
+ * import { clearbit } from '@c15t/scripts/clearbit';
+ *
+ * clearbit({
+ *   publishableKey: 'YOUR_PUBLISHABLE_KEY',
+ * });
+ * ```
+ */
+export declare function clearbit(options: ClearbitOptions): Script;

package/dist-types/vendors/analytics/cloudflare-web-analytics.d.ts

@@ -0,0 +1,67 @@
+import type { Script } from 'c15t';
+declare global {
+    interface Window {
+        __cfBeacon?: {
+            spa?: boolean;
+            token: string;
+        };
+    }
+}
+/**
+ * Cloudflare Web Analytics vendor manifest.
+ *
+ * Serializes Cloudflare's beacon config into the `data-cf-beacon` attribute.
+ * Cloudflare Web Analytics is cookieless, so the script is consent-gated on
+ * `measurement` and unloaded when consent is revoked.
+ */
+export declare const cloudflareWebAnalyticsManifest: {
+    readonly kind: "c15t.vendor-manifest";
+    readonly schemaVersion: 1;
+    readonly vendor: 'cloudflare-web-analytics';
+    readonly category: 'measurement';
+    readonly install: [{
+        readonly type: 'loadScript';
+        readonly src: '{{scriptUrl}}';
+        readonly defer: true;
+        readonly attributes: {
+            readonly 'data-cf-beacon': '{{beaconConfig}}';
+        };
+    }];
+};
+export interface CloudflareWebAnalyticsOptions {
+    /**
+     * Your Cloudflare Web Analytics token.
+     */
+    token: string;
+    /**
+     * Enable Cloudflare's SPA route tracking.
+     * @default true
+     */
+    spa?: boolean;
+    /**
+     * Custom loader URL.
+     * @default 'https://static.cloudflareinsights.com/beacon.min.js'
+     */
+    scriptUrl?: string;
+}
+/**
+ * Creates a Cloudflare Web Analytics script.
+ *
+ * @see https://developers.cloudflare.com/analytics/web-analytics/get-started/
+ *
+ * @param options - The options for the Cloudflare Web Analytics script.
+ * @returns The Cloudflare Web Analytics script.
+ * @throws {Error} Throws `cloudflareWebAnalytics: missing token` when
+ * `options.token` is missing, invalid, or trims to an empty string.
+ *
+ * @example
+ * ```ts
+ * import { cloudflareWebAnalytics } from '@c15t/scripts/cloudflare-web-analytics';
+ *
+ * cloudflareWebAnalytics({
+ *   token: 'abc123...',
+ *   spa: true,
+ * });
+ * ```
+ */
+export declare function cloudflareWebAnalytics(options: CloudflareWebAnalyticsOptions): Script;

package/dist-types/{databuddy.d.ts → vendors/analytics/databuddy.d.ts}

@@ -27,63 +27,63 @@ declare global {
  * Config is seeded via `window.databuddyConfig` before the script loads.
  */
 export declare const databuddyManifest: {
-    readonly vendor: "databuddy";
-    readonly category: "measurement";
+    readonly kind: "c15t.vendor-manifest";
+    readonly schemaVersion: 1;
+    readonly vendor: 'databuddy';
+    readonly category: 'measurement';
     readonly alwaysLoad: true;
     readonly install: [{
-        readonly type: "loadScript";
-        readonly src: "{{scriptUrl}}";
+        readonly type: 'loadScript';
+        readonly src: '{{scriptUrl}}';
         readonly async: true;
         readonly attributes: {
-            readonly crossorigin: "anonymous";
-            readonly 'data-client-id': "{{clientId}}";
-            readonly 'data-api-url': "{{apiUrl}}";
+            readonly crossorigin: 'anonymous';
+            readonly 'data-client-id': '{{clientId}}';
+            readonly 'data-api-url': '{{apiUrl}}';
         };
     }];
     readonly onBeforeLoadGranted: [{
-        readonly type: "setGlobal";
-        readonly name: "databuddyConfig";
-        readonly value: "{{configWhenGranted}}";
+        readonly type: 'setGlobal';
+        readonly name: 'databuddyConfig';
+        readonly value: '{{configWhenGranted}}';
         readonly ifUndefined: true;
     }];
     readonly onBeforeLoadDenied: [{
-        readonly type: "setGlobal";
-        readonly name: "databuddyConfig";
-        readonly value: "{{configWhenDenied}}";
+        readonly type: 'setGlobal';
+        readonly name: 'databuddyConfig';
+        readonly value: '{{configWhenDenied}}';
         readonly ifUndefined: true;
     }];
     readonly onLoadGranted: [{
-        readonly type: "setGlobalPath";
+        readonly type: 'setGlobalPath';
         readonly path: ["databuddy", "options", "disabled"];
         readonly value: false;
     }];
     readonly onLoadDenied: [{
-        readonly type: "setGlobalPath";
+        readonly type: 'setGlobalPath';
         readonly path: ["databuddy", "options", "disabled"];
         readonly value: true;
     }];
     readonly onConsentGranted: [{
-        readonly type: "setGlobal";
-        readonly name: "databuddyConfig";
-        readonly value: "{{configWhenGranted}}";
+        readonly type: 'setGlobal';
+        readonly name: 'databuddyConfig';
+        readonly value: '{{configWhenGranted}}';
         readonly ifUndefined: false;
     }, {
-        readonly type: "setGlobalPath";
+        readonly type: 'setGlobalPath';
         readonly path: ["databuddy", "options", "disabled"];
         readonly value: false;
     }];
     readonly onConsentDenied: [{
-        readonly type: "setGlobal";
-        readonly name: "databuddyConfig";
-        readonly value: "{{configWhenDenied}}";
+        readonly type: 'setGlobal';
+        readonly name: 'databuddyConfig';
+        readonly value: '{{configWhenDenied}}';
         readonly ifUndefined: false;
     }, {
-        readonly type: "setGlobalPath";
+        readonly type: 'setGlobalPath';
         readonly path: ["databuddy", "options", "disabled"];
         readonly value: true;
     }];
-    readonly kind: "c15t.vendor-manifest";
-    readonly schemaVersion: 1;
 };
 export interface DatabuddyConsentOptions {
     /**