@walkeros/web-destination-linkedin 3.3.0-next-1776098542393

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 elbWalker GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,202 @@
+# LinkedIn Web Destination for walkerOS
+
+Forward walkerOS events as LinkedIn Insight Tag conversions
+(`window.lintrk('track', ...)`) — opt-in, per-event, with value + currency +
+deduplication support.
+
+## Source Code
+
+[github.com/elbwalker/walkerOS/tree/main/packages/web/destinations/linkedin](https://github.com/elbwalker/walkerOS/tree/main/packages/web/destinations/linkedin)
+
+## NPM
+
+[`@walkeros/web-destination-linkedin`](https://www.npmjs.com/package/@walkeros/web-destination-linkedin)
+
+## Documentation
+
+[walkeros.io/docs/destinations/web/linkedin](https://www.walkeros.io/docs/destinations/web/linkedin)
+
+## Features
+
+- **Opt-in conversion forwarding** — only events with
+  `mapping.settings.conversion` fire a `lintrk('track')` call. Unmapped events
+  are silently ignored (Campaign Manager requires pre-registered conversion
+  rules).
+- **Automatic page view + retargeting** — the Insight Tag script fires its own
+  page view on load for audience building. The destination does not suppress or
+  duplicate it.
+- **Conversion value + currency** — `data.total`-style mappings with a currency
+  fallback via `{ key, value }` syntax (defaults to `"EUR"`).
+- **Deduplication ready** — maps the walkerOS event `id` to LinkedIn's
+  `event_id`, ready for cross-channel deduplication with a future server
+  (Conversions API) destination.
+- **Consent-gated** — LinkedIn requires `marketing` consent. The collector's
+  `config.consent` gate blocks events until granted; deferred script injection
+  is supported via `loadScript: true`.
+- **Script-tag loader** — no npm SDK dependency. The destination injects
+  `https://snap.licdn.com/li.lms-analytics/insight.min.js` at runtime (opt-in
+  via `loadScript: true`), or you can embed the Insight Tag snippet in your HTML
+  and leave `loadScript: false`.
+
+## Installation
+
+```bash
+npm install @walkeros/web-destination-linkedin
+```
+
+## Quick Start
+
+```json
+{
+  "destinations": {
+    "linkedin": {
+      "package": "@walkeros/web-destination-linkedin",
+      "config": {
+        "consent": { "marketing": true },
+        "loadScript": true,
+        "settings": {
+          "apiKey": "123456"
+        },
+        "mapping": {
+          "order": {
+            "complete": {
+              "settings": {
+                "conversion": {
+                  "map": {
+                    "id": { "value": 67890 },
+                    "value": "data.total",
+                    "currency": { "key": "data.currency", "value": "EUR" },
+                    "eventId": "id"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+## Configuration
+
+### Settings
+
+| Key       | Type       | Required | Notes                                                                                                                                                                                          |
+| --------- | ---------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `apiKey`  | `string`   | yes      | LinkedIn Partner ID (numeric string, e.g. `"123456"`). Find it in Campaign Manager → Insight Tag → Manage Insight Tag.                                                                         |
+| `include` | `string[]` | no       | Event sections made available for mapping resolution. Present for consistency with other destinations — `lintrk()` only accepts four fixed fields, so included data is not automatically sent. |
+
+### Mapping (per-event)
+
+| Key                   | Resolved shape                        | Notes                                                                                                                                             |
+| --------------------- | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `settings.conversion` | `{ id, value?, currency?, eventId? }` | Required for the event to fire. `id` → `conversion_id` (number). Others translate 1:1 to LinkedIn's `conversion_value` / `currency` / `event_id`. |
+
+**Falsy guards:**
+
+- If `id` resolves to falsy/zero → the entire `lintrk` call is skipped (no
+  silent error).
+- If `value` / `currency` / `eventId` resolve to falsy → those fields are
+  omitted from the call (`id` still required).
+
+## Events
+
+### Opt-in model
+
+LinkedIn is an **opt-in conversion platform**. Every tracked event must
+reference a pre-created Conversion Rule in Campaign Manager via its numeric
+`conversion_id`. Events without an explicit `mapping.settings.conversion` are
+silently ignored — they produce zero `lintrk` calls.
+
+This is the opposite of analytics destinations (Amplitude, Clarity, PostHog)
+which forward every event by default.
+
+### Conversion with value and deduplication
+
+```json
+"mapping": {
+  "order": {
+    "complete": {
+      "settings": {
+        "conversion": {
+          "map": {
+            "id": { "value": 67890 },
+            "value": "data.total",
+            "currency": { "key": "data.currency", "value": "EUR" },
+            "eventId": "id"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+Resolves to:
+`lintrk('track', { conversion_id: 67890, conversion_value: 555, currency: 'EUR', event_id: '<walker-event-id>' })`.
+
+### Skipping a fully configured rule
+
+```json
+"mapping": {
+  "form": {
+    "submit": {
+      "skip": true,
+      "settings": {
+        "conversion": { "map": { "id": { "value": 12345 } } }
+      }
+    }
+  }
+}
+```
+
+`mapping.skip: true` suppresses the call while keeping the rule on disk for
+quick reactivation. Alternatively, simply omit `settings.conversion` —
+LinkedIn's opt-in model makes that equivalent.
+
+## Consent
+
+LinkedIn is an advertising platform. The Insight Tag falls under **marketing**
+consent (not analytics):
+
+```json
+"config": {
+  "consent": { "marketing": true }
+}
+```
+
+walkerOS's collector blocks all events to this destination until `marketing` is
+granted. When consent is later revoked, walkerOS stops sending events — the
+LinkedIn Insight Tag itself has no `opt_out()` API, so the tag remains loaded
+but receives no further calls.
+
+### Deferred script load
+
+If you want the Insight Tag script to load **only** after consent is granted,
+set `loadScript: true` and leave `config.consent.marketing` un-granted at init
+time. The destination will skip `addScript()` during init and inject the script
+when an `on('consent')` event grants marketing.
+
+## No identity tracking
+
+LinkedIn identity on the web is cookie-based — the Insight Tag manages its own
+first-party cookies and matches visitors against LinkedIn member profiles
+server-side. There is no `lintrk('identify', ...)` API. The destination does
+**not** forward user IDs, emails, phone numbers, or the `li_fat_id` click ID.
+
+Click-ID capture (including `li_fat_id`) is the session source's responsibility.
+A future `@walkeros/server-destination-linkedin` (Conversions API) will consume
+`li_fat_id` from `user.device` for advanced matching.
+
+## Future: Conversions API
+
+A server-side Conversions API destination is planned as a follow-up, matching
+the TikTok / Pinterest / Meta pattern. It will share the `event_id` field with
+this web destination for cross-channel deduplication.
+
+## Related
+
+- Insight Tag official docs:
+  [LinkedIn Help Center](https://www.linkedin.com/help/lms/answer/a427660)

package/dist/dev.d.mts

@@ -0,0 +1,229 @@
+import * as _walkeros_core_dev from '@walkeros/core/dev';
+import { z } from '@walkeros/core/dev';
+import { DestinationWeb } from '@walkeros/web-core';
+import { Flow } from '@walkeros/core';
+
+declare const SettingsSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+}, z.core.$strip>;
+type Settings$1 = z.infer<typeof SettingsSchema>;
+
+/**
+ * LinkedIn per-rule mapping schema.
+ *
+ * Every field on `conversion` is a walkerOS mapping value (static literal,
+ * string path, or `{ map, value, key, fn, ... }` object). The schema uses
+ * `z.unknown()` for each so users can supply any valid mapping shape — the
+ * destination resolves it via `getMappingValue()` at push time.
+ */
+declare const MappingSchema: z.ZodObject<{
+    conversion: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+type Mapping = z.infer<typeof MappingSchema>;
+
+declare const settings: _walkeros_core_dev.JSONSchema;
+declare const mapping: _walkeros_core_dev.JSONSchema;
+
+type index$1_Mapping = Mapping;
+declare const index$1_MappingSchema: typeof MappingSchema;
+declare const index$1_SettingsSchema: typeof SettingsSchema;
+declare const index$1_mapping: typeof mapping;
+declare const index$1_settings: typeof settings;
+declare namespace index$1 {
+  export { type index$1_Mapping as Mapping, index$1_MappingSchema as MappingSchema, type Settings$1 as Settings, index$1_SettingsSchema as SettingsSchema, index$1_mapping as mapping, index$1_settings as settings };
+}
+
+/**
+ * LinkedIn Insight Tag runtime surface.
+ *
+ * The Insight Tag script installs `window.lintrk` — a single function that
+ * accepts exactly one tracked action: `lintrk('track', data)`.
+ *
+ * Before the script loads, the destination installs a queue-backed shim so
+ * calls made during init are buffered and flushed once the script loads.
+ * This mirrors the pattern LinkedIn's own snippet uses.
+ */
+type LintrkAction = 'track';
+interface LintrkTrackData {
+    conversion_id: number;
+    conversion_value?: number;
+    currency?: string;
+    event_id?: string;
+}
+type Lintrk = ((action: LintrkAction, data: LintrkTrackData) => void) & {
+    /** Internal queue populated before the CDN script loads. */
+    q?: unknown[];
+};
+declare global {
+    interface Window {
+        _linkedin_partner_id?: string;
+        _linkedin_data_partner_ids?: string[];
+        lintrk?: Lintrk;
+    }
+}
+/**
+ * Destination-level settings.
+ *
+ * apiKey — the LinkedIn Partner ID (numeric string, e.g. "123456"), assigned
+ *          to `window._linkedin_partner_id` before the script loads.
+ * include — event sections made available for mapping resolution. Present for
+ *          consistency with other destinations; has no effect at call time
+ *          because `lintrk()` only accepts four fixed fields. Kept so users
+ *          can reference section-prefixed keys in future custom mapping
+ *          strategies without a breaking change.
+ */
+interface Settings {
+    apiKey: string;
+}
+/**
+ * Env — mock surface for tests and dev. The destination mutates
+ * `window._linkedin_partner_id` / `window._linkedin_data_partner_ids` and
+ * installs `window.lintrk` in init; tests can pre-seed `window.lintrk` with
+ * a spy to skip the script injection path.
+ *
+ * `document` is also mocked so `addScript()` can run headlessly.
+ */
+interface Env extends DestinationWeb.Env {
+    window: {
+        _linkedin_partner_id?: string;
+        _linkedin_data_partner_ids?: string[];
+        lintrk?: Lintrk;
+    };
+}
+
+/**
+ * Pre-init environment — no LinkedIn state present. The destination's init
+ * will populate _linkedin_partner_id and install the lintrk queue.
+ */
+declare const init: Env | undefined;
+/**
+ * Post-init environment — lintrk is a spy-able no-op function carrying the
+ * queue shape the real script installs. Tests clone this and replace
+ * `window.lintrk` with a jest.fn() before pushing events, so every call is
+ * captured.
+ */
+declare const push: Env;
+/**
+ * Simulation tracking paths — used by CLI `--simulate` to record which
+ * function calls happened during an event push.
+ */
+declare const simulation: string[];
+
+declare const env_init: typeof init;
+declare const env_push: typeof push;
+declare const env_simulation: typeof simulation;
+declare namespace env {
+  export { env_init as init, env_push as push, env_simulation as simulation };
+}
+
+/**
+ * Examples may optionally override destination-level settings for a test.
+ * The test runner reads `settings` from the example and merges it into the
+ * base destination settings (on top of the fixed `apiKey`). Rarely needed
+ * for LinkedIn — conversion config lives on the rule, not destination-level.
+ */
+type LinkedInStepExample = Flow.StepExample & {
+    settings?: Partial<Settings>;
+};
+/**
+ * OPT-IN: Unmapped event is silently ignored.
+ *
+ * LinkedIn's core behavioral difference from analytics destinations: events
+ * without `mapping.settings.conversion` produce ZERO lintrk() calls. The
+ * destination is opt-in — each conversion must reference a pre-created
+ * Conversion Rule from Campaign Manager.
+ */
+declare const unmappedEventIgnored: LinkedInStepExample;
+/**
+ * Simplest possible conversion — just a `conversion_id` from Campaign Manager.
+ *
+ * Form submission → LinkedIn Lead conversion. The mapping resolves `id` as a
+ * literal value (no walker event field needed). The destination translates
+ * `{ id }` → `lintrk('track', { conversion_id })`.
+ */
+declare const simpleConversionId: LinkedInStepExample;
+/**
+ * Full e-commerce conversion — every supported lintrk field populated.
+ *
+ * mapping config uses short walkerOS keys (`id`, `value`, `currency`, `eventId`);
+ * the destination translates them to the vendor parameter names
+ * (`conversion_id`, `conversion_value`, `currency`, `event_id`).
+ *
+ * Currency uses the walkerOS fallback syntax: `{ key, value }` — pull from
+ * `data.currency` first, fall back to `"EUR"` if absent. The default
+ * `order complete` fixture from `getEvent` already sets `data.currency: "EUR"`,
+ * so the resolved value is "EUR" here.
+ *
+ * `eventId` maps from the walkerOS event.id — stable per event, unique, and
+ * ready for deduplication with a future server (Conversions API) destination.
+ */
+declare const orderCompleteFullConversion: LinkedInStepExample;
+/**
+ * Page view as an explicit conversion.
+ *
+ * LinkedIn's Insight Tag automatically fires a page view on load for
+ * retargeting / audience building — that call is NOT something the
+ * destination controls. This example tests the OTHER case: mapping a
+ * specific walkerOS `page view` event to a Campaign Manager KEY_PAGE_VIEW
+ * conversion rule, which fires an EXPLICIT lintrk('track') call in addition
+ * to the auto page view.
+ */
+declare const pageViewConversion: LinkedInStepExample;
+/**
+ * Middle-funnel LEAD conversion — demo request without monetary value.
+ *
+ * LinkedIn's conversion types include LEAD, CONTACT, SIGN_UP, etc. The
+ * destination is agnostic to the type (set in Campaign Manager, not at call
+ * time) — all we forward is the conversion_id. This fixture exercises the
+ * "id + eventId only" shape.
+ */
+declare const demoRequestLead: LinkedInStepExample;
+/**
+ * rule.skip — fully-configured conversion rule temporarily disabled.
+ *
+ * The rule has a valid `conversion.map` but `skip: true` tells the destination
+ * to produce zero calls. This is distinct from the opt-in default (no
+ * `conversion` at all): skip explicitly keeps the rule on disk for quick
+ * reactivation without deleting it.
+ */
+declare const conversionSkipped: LinkedInStepExample;
+/**
+ * Falsy `id` → entire lintrk call is skipped.
+ *
+ * If the resolved conversion object has no truthy `id`, the destination does
+ * NOT call lintrk at all. This protects against misconfigured mappings
+ * (e.g. pulling id from a non-existent field).
+ *
+ * Here we map `id` from `data.nonexistentField` — it resolves to undefined,
+ * so zero calls are produced.
+ */
+declare const missingConversionIdIgnored: LinkedInStepExample;
+/**
+ * Partial conversion — value missing → omitted from the lintrk call.
+ *
+ * The rule asks for `value: 'data.missingTotal'` (undefined), `currency`
+ * (undefined), and `eventId: 'id'` (present). Only `conversion_id` and
+ * `event_id` appear in the final call — no `conversion_value`, no `currency`.
+ */
+declare const partialFieldsOmitted: LinkedInStepExample;
+
+type step_LinkedInStepExample = LinkedInStepExample;
+declare const step_conversionSkipped: typeof conversionSkipped;
+declare const step_demoRequestLead: typeof demoRequestLead;
+declare const step_missingConversionIdIgnored: typeof missingConversionIdIgnored;
+declare const step_orderCompleteFullConversion: typeof orderCompleteFullConversion;
+declare const step_pageViewConversion: typeof pageViewConversion;
+declare const step_partialFieldsOmitted: typeof partialFieldsOmitted;
+declare const step_simpleConversionId: typeof simpleConversionId;
+declare const step_unmappedEventIgnored: typeof unmappedEventIgnored;
+declare namespace step {
+  export { type step_LinkedInStepExample as LinkedInStepExample, step_conversionSkipped as conversionSkipped, step_demoRequestLead as demoRequestLead, step_missingConversionIdIgnored as missingConversionIdIgnored, step_orderCompleteFullConversion as orderCompleteFullConversion, step_pageViewConversion as pageViewConversion, step_partialFieldsOmitted as partialFieldsOmitted, step_simpleConversionId as simpleConversionId, step_unmappedEventIgnored as unmappedEventIgnored };
+}
+
+declare const index_env: typeof env;
+declare const index_step: typeof step;
+declare namespace index {
+  export { index_env as env, index_step as step };
+}
+
+export { index as examples, index$1 as schemas };

package/dist/dev.d.ts

@@ -0,0 +1,229 @@
+import * as _walkeros_core_dev from '@walkeros/core/dev';
+import { z } from '@walkeros/core/dev';
+import { DestinationWeb } from '@walkeros/web-core';
+import { Flow } from '@walkeros/core';
+
+declare const SettingsSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+}, z.core.$strip>;
+type Settings$1 = z.infer<typeof SettingsSchema>;
+
+/**
+ * LinkedIn per-rule mapping schema.
+ *
+ * Every field on `conversion` is a walkerOS mapping value (static literal,
+ * string path, or `{ map, value, key, fn, ... }` object). The schema uses
+ * `z.unknown()` for each so users can supply any valid mapping shape — the
+ * destination resolves it via `getMappingValue()` at push time.
+ */
+declare const MappingSchema: z.ZodObject<{
+    conversion: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+type Mapping = z.infer<typeof MappingSchema>;
+
+declare const settings: _walkeros_core_dev.JSONSchema;
+declare const mapping: _walkeros_core_dev.JSONSchema;
+
+type index$1_Mapping = Mapping;
+declare const index$1_MappingSchema: typeof MappingSchema;
+declare const index$1_SettingsSchema: typeof SettingsSchema;
+declare const index$1_mapping: typeof mapping;
+declare const index$1_settings: typeof settings;
+declare namespace index$1 {
+  export { type index$1_Mapping as Mapping, index$1_MappingSchema as MappingSchema, type Settings$1 as Settings, index$1_SettingsSchema as SettingsSchema, index$1_mapping as mapping, index$1_settings as settings };
+}
+
+/**
+ * LinkedIn Insight Tag runtime surface.
+ *
+ * The Insight Tag script installs `window.lintrk` — a single function that
+ * accepts exactly one tracked action: `lintrk('track', data)`.
+ *
+ * Before the script loads, the destination installs a queue-backed shim so
+ * calls made during init are buffered and flushed once the script loads.
+ * This mirrors the pattern LinkedIn's own snippet uses.
+ */
+type LintrkAction = 'track';
+interface LintrkTrackData {
+    conversion_id: number;
+    conversion_value?: number;
+    currency?: string;
+    event_id?: string;
+}
+type Lintrk = ((action: LintrkAction, data: LintrkTrackData) => void) & {
+    /** Internal queue populated before the CDN script loads. */
+    q?: unknown[];
+};
+declare global {
+    interface Window {
+        _linkedin_partner_id?: string;
+        _linkedin_data_partner_ids?: string[];
+        lintrk?: Lintrk;
+    }
+}
+/**
+ * Destination-level settings.
+ *
+ * apiKey — the LinkedIn Partner ID (numeric string, e.g. "123456"), assigned
+ *          to `window._linkedin_partner_id` before the script loads.
+ * include — event sections made available for mapping resolution. Present for
+ *          consistency with other destinations; has no effect at call time
+ *          because `lintrk()` only accepts four fixed fields. Kept so users
+ *          can reference section-prefixed keys in future custom mapping
+ *          strategies without a breaking change.
+ */
+interface Settings {
+    apiKey: string;
+}
+/**
+ * Env — mock surface for tests and dev. The destination mutates
+ * `window._linkedin_partner_id` / `window._linkedin_data_partner_ids` and
+ * installs `window.lintrk` in init; tests can pre-seed `window.lintrk` with
+ * a spy to skip the script injection path.
+ *
+ * `document` is also mocked so `addScript()` can run headlessly.
+ */
+interface Env extends DestinationWeb.Env {
+    window: {
+        _linkedin_partner_id?: string;
+        _linkedin_data_partner_ids?: string[];
+        lintrk?: Lintrk;
+    };
+}
+
+/**
+ * Pre-init environment — no LinkedIn state present. The destination's init
+ * will populate _linkedin_partner_id and install the lintrk queue.
+ */
+declare const init: Env | undefined;
+/**
+ * Post-init environment — lintrk is a spy-able no-op function carrying the
+ * queue shape the real script installs. Tests clone this and replace
+ * `window.lintrk` with a jest.fn() before pushing events, so every call is
+ * captured.
+ */
+declare const push: Env;
+/**
+ * Simulation tracking paths — used by CLI `--simulate` to record which
+ * function calls happened during an event push.
+ */
+declare const simulation: string[];
+
+declare const env_init: typeof init;
+declare const env_push: typeof push;
+declare const env_simulation: typeof simulation;
+declare namespace env {
+  export { env_init as init, env_push as push, env_simulation as simulation };
+}
+
+/**
+ * Examples may optionally override destination-level settings for a test.
+ * The test runner reads `settings` from the example and merges it into the
+ * base destination settings (on top of the fixed `apiKey`). Rarely needed
+ * for LinkedIn — conversion config lives on the rule, not destination-level.
+ */
+type LinkedInStepExample = Flow.StepExample & {
+    settings?: Partial<Settings>;
+};
+/**
+ * OPT-IN: Unmapped event is silently ignored.
+ *
+ * LinkedIn's core behavioral difference from analytics destinations: events
+ * without `mapping.settings.conversion` produce ZERO lintrk() calls. The
+ * destination is opt-in — each conversion must reference a pre-created
+ * Conversion Rule from Campaign Manager.
+ */
+declare const unmappedEventIgnored: LinkedInStepExample;
+/**
+ * Simplest possible conversion — just a `conversion_id` from Campaign Manager.
+ *
+ * Form submission → LinkedIn Lead conversion. The mapping resolves `id` as a
+ * literal value (no walker event field needed). The destination translates
+ * `{ id }` → `lintrk('track', { conversion_id })`.
+ */
+declare const simpleConversionId: LinkedInStepExample;
+/**
+ * Full e-commerce conversion — every supported lintrk field populated.
+ *
+ * mapping config uses short walkerOS keys (`id`, `value`, `currency`, `eventId`);
+ * the destination translates them to the vendor parameter names
+ * (`conversion_id`, `conversion_value`, `currency`, `event_id`).
+ *
+ * Currency uses the walkerOS fallback syntax: `{ key, value }` — pull from
+ * `data.currency` first, fall back to `"EUR"` if absent. The default
+ * `order complete` fixture from `getEvent` already sets `data.currency: "EUR"`,
+ * so the resolved value is "EUR" here.
+ *
+ * `eventId` maps from the walkerOS event.id — stable per event, unique, and
+ * ready for deduplication with a future server (Conversions API) destination.
+ */
+declare const orderCompleteFullConversion: LinkedInStepExample;
+/**
+ * Page view as an explicit conversion.
+ *
+ * LinkedIn's Insight Tag automatically fires a page view on load for
+ * retargeting / audience building — that call is NOT something the
+ * destination controls. This example tests the OTHER case: mapping a
+ * specific walkerOS `page view` event to a Campaign Manager KEY_PAGE_VIEW
+ * conversion rule, which fires an EXPLICIT lintrk('track') call in addition
+ * to the auto page view.
+ */
+declare const pageViewConversion: LinkedInStepExample;
+/**
+ * Middle-funnel LEAD conversion — demo request without monetary value.
+ *
+ * LinkedIn's conversion types include LEAD, CONTACT, SIGN_UP, etc. The
+ * destination is agnostic to the type (set in Campaign Manager, not at call
+ * time) — all we forward is the conversion_id. This fixture exercises the
+ * "id + eventId only" shape.
+ */
+declare const demoRequestLead: LinkedInStepExample;
+/**
+ * rule.skip — fully-configured conversion rule temporarily disabled.
+ *
+ * The rule has a valid `conversion.map` but `skip: true` tells the destination
+ * to produce zero calls. This is distinct from the opt-in default (no
+ * `conversion` at all): skip explicitly keeps the rule on disk for quick
+ * reactivation without deleting it.
+ */
+declare const conversionSkipped: LinkedInStepExample;
+/**
+ * Falsy `id` → entire lintrk call is skipped.
+ *
+ * If the resolved conversion object has no truthy `id`, the destination does
+ * NOT call lintrk at all. This protects against misconfigured mappings
+ * (e.g. pulling id from a non-existent field).
+ *
+ * Here we map `id` from `data.nonexistentField` — it resolves to undefined,
+ * so zero calls are produced.
+ */
+declare const missingConversionIdIgnored: LinkedInStepExample;
+/**
+ * Partial conversion — value missing → omitted from the lintrk call.
+ *
+ * The rule asks for `value: 'data.missingTotal'` (undefined), `currency`
+ * (undefined), and `eventId: 'id'` (present). Only `conversion_id` and
+ * `event_id` appear in the final call — no `conversion_value`, no `currency`.
+ */
+declare const partialFieldsOmitted: LinkedInStepExample;
+
+type step_LinkedInStepExample = LinkedInStepExample;
+declare const step_conversionSkipped: typeof conversionSkipped;
+declare const step_demoRequestLead: typeof demoRequestLead;
+declare const step_missingConversionIdIgnored: typeof missingConversionIdIgnored;
+declare const step_orderCompleteFullConversion: typeof orderCompleteFullConversion;
+declare const step_pageViewConversion: typeof pageViewConversion;
+declare const step_partialFieldsOmitted: typeof partialFieldsOmitted;
+declare const step_simpleConversionId: typeof simpleConversionId;
+declare const step_unmappedEventIgnored: typeof unmappedEventIgnored;
+declare namespace step {
+  export { type step_LinkedInStepExample as LinkedInStepExample, step_conversionSkipped as conversionSkipped, step_demoRequestLead as demoRequestLead, step_missingConversionIdIgnored as missingConversionIdIgnored, step_orderCompleteFullConversion as orderCompleteFullConversion, step_pageViewConversion as pageViewConversion, step_partialFieldsOmitted as partialFieldsOmitted, step_simpleConversionId as simpleConversionId, step_unmappedEventIgnored as unmappedEventIgnored };
+}
+
+declare const index_env: typeof env;
+declare const index_step: typeof step;
+declare namespace index {
+  export { index_env as env, index_step as step };
+}
+
+export { index as examples, index$1 as schemas };