@walkeros/web-destination-segment 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,372 @@
+<p align="left">
+  <a href="https://www.walkeros.io">
+    <img alt="walkerOS" title="walkerOS" src="https://www.walkeros.io/img/walkerOS_logo.svg" width="256px"/>
+  </a>
+</p>
+
+# Segment CDP Destination for walkerOS
+
+[Source Code](https://github.com/elbwalker/walkerOS/tree/main/packages/web/destinations/segment)
+&bull;
+[NPM Package](https://www.npmjs.com/package/@walkeros/web-destination-segment)
+&bull; [Documentation](https://www.walkeros.io/docs/destinations/web/segment)
+
+This package forwards walkerOS events to [Segment](https://segment.com/) — the
+customer data platform that routes your event data to 400+ downstream
+destinations. Built on the official
+[`@segment/analytics-next`](https://www.npmjs.com/package/@segment/analytics-next)
+(Analytics.js 2.0) SDK.
+
+walkerOS follows a **source → collector → destination** architecture. This
+Segment destination receives processed events from the walkerOS collector and
+forwards them via the full Segment Spec surface: `track`, `identify`, `group`,
+`page`, and `reset`.
+
+## Features
+
+- **Default event forwarding** — every walkerOS event becomes
+  `analytics.track(name, properties)` with no additional config
+- **Custom event properties** — flatten walkerOS sections with
+  `settings.include` (`data_*`, `globals_*`, etc.) or produce fully-shaped
+  Segment Spec properties via `mapping.data`
+- **Identity** — destination-level or per-event `settings.identify` resolving to
+  `{ userId, traits, anonymousId }`, with runtime state diffing so redundant
+  `identify()` calls are skipped
+- **Groups** — `settings.group` with Segment-reserved group traits (`name`,
+  `industry`, `employees`, `plan`, ...)
+- **Page views** — first-class `analytics.page(category, name, properties)` via
+  explicit `mapping.settings.page` configuration
+- **Reset on logout** — `settings.reset: true` calls `analytics.reset()` so the
+  current user identity is cleared
+- **Consent context forwarding** — walkerOS consent state is automatically
+  stamped as `context.consent.categoryPreferences` on every call, with optional
+  `settings.consent` key remapping
+- **Deferred-load consent pattern** — when `config.consent` is declared,
+  `AnalyticsBrowser.load()` is held until the first grant
+- **Ecommerce via the Segment Spec** — walkerOS `mapping.name` + `mapping.data`
+  produce PascalCase event names (`Order Completed`) with a `products` array, a
+  single `track()` call per order (no loop)
+
+## Installation
+
+```sh
+npm install @walkeros/web-destination-segment
+```
+
+## Quick Start
+
+```typescript
+import { startFlow } from '@walkeros/collector';
+import { destinationSegment } from '@walkeros/web-destination-segment';
+
+await startFlow({
+  destinations: {
+    segment: {
+      code: destinationSegment,
+      config: {
+        settings: {
+          apiKey: 'YOUR_SEGMENT_WRITE_KEY',
+        },
+      },
+    },
+  },
+});
+```
+
+## Configuration
+
+### Settings (destination-level)
+
+The `Settings` type extends Segment's `InitOptions`, so every passthrough option
+(cookie, storage, integrations, plan, retryQueue, ...) works alongside the
+walkerOS-specific fields listed below.
+
+| Name                       | Type                     | Description                                                                                                         | Required |
+| -------------------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------- | -------- |
+| `apiKey`                   | `string`                 | Your Segment source write key — maps to `writeKey` in `AnalyticsBrowser.load()`                                     | Yes      |
+| `identify`                 | `Mapping.Value`          | Destination-level identity mapping resolving to `{ userId, traits, anonymousId }`                                   | No       |
+| `group`                    | `Mapping.Value`          | Destination-level group mapping resolving to `{ groupId, traits }`                                                  | No       |
+| `include`                  | `string[]`               | walkerOS event sections to flatten into Segment `properties` (`data`, `globals`, `context`, `user`, `event`, `all`) | No       |
+| `consent`                  | `Record<string, string>` | Mapping from walkerOS consent keys → Segment `categoryPreferences` keys (e.g. `{ marketing: 'Advertising' }`)       | No       |
+| `initialPageview`          | `boolean`                | Default `false` — walkerOS sources handle page tracking, so the SDK's auto pageview is disabled                     | No       |
+| `disableClientPersistence` | `boolean`                | Disable all cookie / localStorage writes                                                                            | No       |
+| `integrations`             | `object`                 | Enable/disable downstream Segment destinations. Example: `{ All: true, Mixpanel: false }`                           | No       |
+
+### Mapping (`rule.settings`)
+
+| Name       | Type                    | Description                                                                                                 |
+| ---------- | ----------------------- | ----------------------------------------------------------------------------------------------------------- |
+| `identify` | `Mapping.Value`         | Per-event identity override; resolves to `{ userId, traits, anonymousId }`                                  |
+| `group`    | `Mapping.Value`         | Per-event group assignment; resolves to `{ groupId, traits }`                                               |
+| `page`     | `Mapping.Value \| true` | Page call config. `true` → empty `analytics.page()`. Object resolves to `{ category?, name?, properties? }` |
+| `reset`    | `Mapping.Value \| true` | Logout trigger. Truthy → `analytics.reset()`                                                                |
+| `include`  | `string[]`              | Override destination-level `include` for this rule                                                          |
+
+Use `mapping.skip: true` to suppress the default `analytics.track()` call when a
+rule runs identity / group / page side effects only.
+
+## Event Properties
+
+Two ways to shape Segment track properties:
+
+```typescript
+// 1. Flatten walkerOS sections via settings.include
+config: {
+  settings: {
+    apiKey: 'WRITE_KEY',
+    include: ['data', 'globals'], // → data_*, globals_* props on every event
+  },
+}
+
+// 2. Build Segment-Spec-shaped properties via mapping.data
+mapping: {
+  order: {
+    complete: {
+      name: 'Order Completed',
+      data: {
+        map: {
+          order_id: 'data.id',
+          currency: { key: 'data.currency', value: 'EUR' },
+          shipping: 'data.shipping',
+          tax: 'data.taxes',
+          total: 'data.total',
+          products: {
+            loop: [
+              'nested',
+              {
+                condition: (v) => typeof v?.data?.price === 'number',
+                map: {
+                  product_id: 'data.id',
+                  name: 'data.name',
+                  price: 'data.price',
+                  quantity: { key: 'data.quantity', value: 1 },
+                  currency: { key: 'data.currency', value: 'EUR' },
+                },
+              },
+            ],
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+The Segment Ecommerce Spec uses a **single**
+`track('Order Completed', { products: [...] })` call — not a loop of N revenue
+calls. walkerOS `mapping.data` with a nested `loop` over `nested` builds the
+products array inline.
+
+## Identity
+
+Destination-level identity fires on every push (with state diffing to skip
+redundant calls):
+
+```typescript
+config: {
+  settings: {
+    apiKey: 'WRITE_KEY',
+    identify: {
+      map: {
+        userId: 'user.id',
+        traits: {
+          map: {
+            email: 'user.email',
+            name: 'user.name',
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+Per-event identity uses a mapping rule with `skip: true` so only the identity
+side effect runs (not a default `track()`):
+
+```typescript
+mapping: {
+  user: {
+    login: {
+      skip: true,
+      settings: {
+        identify: {
+          map: {
+            userId: 'data.user_id',
+            traits: {
+              map: {
+                email: 'data.email',
+                plan: 'data.plan',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+### Reserved Traits (Segment Spec)
+
+Use these trait names so downstream destinations recognize them: `email`,
+`name`, `firstName`, `lastName`, `phone`, `avatar`, `birthday`, `plan`,
+`company`, `createdAt`, `title`, `username`, `gender`, `age`.
+
+## Groups
+
+```typescript
+mapping: {
+  company: {
+    update: {
+      skip: true,
+      settings: {
+        group: {
+          map: {
+            groupId: 'data.company_id',
+            traits: {
+              map: {
+                name: 'data.company_name',
+                industry: 'data.industry',
+                employees: 'data.employees',
+                plan: 'data.plan',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+Reserved Segment group traits: `name`, `industry`, `employees`, `plan`,
+`createdAt`, `description`, `email`, `website`.
+
+## Page Views
+
+Segment's `page()` is first-class — walkerOS `page view` events should map to
+`analytics.page()`, not `analytics.track('page view')`. Configure explicitly via
+`mapping.settings.page`:
+
+```typescript
+mapping: {
+  page: {
+    view: {
+      skip: true,
+      settings: {
+        page: {
+          map: {
+            category: 'data.category',
+            name: 'data.title',
+            properties: {
+              map: {
+                section: 'data.section',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+Or the minimal form (`true`) that fires an empty `analytics.page()` and relies
+on the SDK's automatic url/path/referrer/title collection:
+
+```typescript
+mapping: {
+  page: {
+    view: {
+      skip: true,
+      settings: {
+        page: true,
+      },
+    },
+  },
+}
+```
+
+## Consent
+
+The destination supports two complementary consent mechanisms:
+
+**Automatic context forwarding.** When `settings.consent` is configured, the
+destination stamps every `track`, `identify`, `group`, and `page` call with
+`context.consent.categoryPreferences`:
+
+```typescript
+config: {
+  settings: {
+    apiKey: 'WRITE_KEY',
+    consent: {
+      analytics: 'Analytics',
+      marketing: 'Advertising',
+    },
+  },
+}
+```
+
+When the walker emits an event with
+`consent: { analytics: true, marketing: true }`, the destination calls
+`analytics.track(name, props, { context: { consent: { categoryPreferences: { Analytics: true, Advertising: true } } } })`.
+
+**Deferred-load consent pattern.** When `config.consent` is declared,
+`AnalyticsBrowser.load()` is held until the first `walker consent` command that
+grants all required keys. Once granted, the SDK loads and all queued events
+flush:
+
+```typescript
+destinations: {
+  segment: {
+    code: destinationSegment,
+    config: {
+      consent: { analytics: true },
+      settings: { apiKey: 'WRITE_KEY' },
+    },
+  },
+}
+```
+
+This is the primary consent mechanism for Segment, since Segment's SDK has no
+`optOut()` method — the only way to enforce consent is to avoid loading the SDK
+in the first place.
+
+## Reset (Logout)
+
+```typescript
+mapping: {
+  user: {
+    logout: {
+      skip: true,
+      settings: {
+        reset: true,
+      },
+    },
+  },
+}
+```
+
+`analytics.reset()` clears the stored `userId`, `anonymousId`, and traits, then
+generates a fresh anonymous ID.
+
+## Scope Notes
+
+- **`alias()` and `screen()`** are intentionally deferred. `alias()` is a legacy
+  identity-linking method (most identity resolution happens server-side in
+  Segment Profiles); `screen()` is mobile-only.
+- **Plugins, source middleware, and destination middleware** cannot be
+  serialized in JSON flow configs. Register them programmatically on the
+  returned `AnalyticsBrowser` instance if needed.
+
+## Contribute
+
+Feel free to contribute by submitting an
+[issue](https://github.com/elbwalker/walkerOS/issues), starting a
+[discussion](https://github.com/elbwalker/walkerOS/discussions), or getting in
+[contact](https://calendly.com/elb-alexander/30min).
+
+## License
+
+This project is licensed under the MIT License.

package/dist/dev.d.mts

@@ -0,0 +1,277 @@
+import * as _walkeros_core_dev from '@walkeros/core/dev';
+import { z } from '@walkeros/core/dev';
+import { Mapping as Mapping$1, Flow } from '@walkeros/core';
+import { DestinationWeb } from '@walkeros/web-core';
+import { AnalyticsBrowserSettings, InitOptions } from '@segment/analytics-next';
+
+declare const SettingsSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+    cdnURL: z.ZodOptional<z.ZodString>;
+    initialPageview: z.ZodOptional<z.ZodBoolean>;
+    disableClientPersistence: z.ZodOptional<z.ZodBoolean>;
+    disableAutoISOConversion: z.ZodOptional<z.ZodBoolean>;
+    retryQueue: z.ZodOptional<z.ZodBoolean>;
+    obfuscate: z.ZodOptional<z.ZodBoolean>;
+    integrations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    identify: z.ZodOptional<z.ZodUnknown>;
+    group: z.ZodOptional<z.ZodUnknown>;
+    consent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type Settings$1 = z.infer<typeof SettingsSchema>;
+
+declare const MappingSchema: z.ZodObject<{
+    identify: z.ZodOptional<z.ZodUnknown>;
+    group: z.ZodOptional<z.ZodUnknown>;
+    page: z.ZodOptional<z.ZodUnknown>;
+    reset: 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 };
+}
+
+/**
+ * Destination-level settings.
+ *
+ * Extends Segment's `InitOptions` (minus the `group` key which clashes with
+ * walkerOS's own `group` mapping) so every passthrough option (cookie,
+ * storage, integrations, plan, etc.) keeps IntelliSense intact. walkerOS
+ * adds:
+ *  - `apiKey` (required) — maps to `writeKey` in `AnalyticsBrowser.load()`
+ *  - `identify` — destination-level identity mapping (Segment `identify()`)
+ *  - `group` — destination-level group mapping (Segment `group()`)
+ *  - `include` — event sections flattened into track `properties`
+ *  - `consent` — walkerOS consent key → Segment category name mapping
+ *  - `_state` — runtime state (not user-facing, mutated by init/push)
+ */
+interface Settings extends Omit<InitOptions, 'group'> {
+    /** Segment write key. Maps to `writeKey` in the load() settings arg. */
+    apiKey: string;
+    /** walkerOS mapping value resolving to an identity object (userId, traits, anonymousId). */
+    identify?: Mapping$1.Value;
+    /** walkerOS mapping value resolving to a group object (groupId, traits). */
+    group?: Mapping$1.Value;
+    /**
+     * Mapping from walkerOS consent keys → Segment `categoryPreferences` keys.
+     * Example: { marketing: "Advertising", analytics: "Analytics" }
+     * If omitted, walkerOS keys are forwarded 1:1.
+     */
+    consent?: Record<string, string>;
+    /** Runtime state — populated by init() and mutated by push(). Not user-facing. */
+    _state?: RuntimeState;
+}
+interface RuntimeState {
+    /** Last-set identity values, used to skip redundant identify() calls. */
+    lastIdentity?: {
+        userId?: string;
+        anonymousId?: string;
+        traitsHash?: string;
+    };
+    /** Last-set group assignment, used to skip redundant group() calls. */
+    lastGroup?: {
+        groupId?: string;
+        traitsHash?: string;
+    };
+    /** Holds the AnalyticsBrowser instance created in init(). */
+    analytics?: SegmentAnalytics;
+    /** True once load() has been called (may be deferred pending consent). */
+    loaded?: boolean;
+}
+/**
+ * Segment SDK surface — the subset of @segment/analytics-next the
+ * destination actually uses. Mirrors the AnalyticsBrowser instance shape
+ * so tests can mock each method individually via env.analytics.
+ */
+interface SegmentAnalytics {
+    track: (event: string, properties?: Record<string, unknown>, options?: SegmentEventOptions) => Promise<unknown> | void;
+    identify: (userId?: string | Record<string, unknown>, traits?: Record<string, unknown>, options?: SegmentEventOptions) => Promise<unknown> | void;
+    group: (groupId: string, traits?: Record<string, unknown>, options?: SegmentEventOptions) => Promise<unknown> | void;
+    page: (category?: string | null, name?: string | null, properties?: Record<string, unknown>, options?: SegmentEventOptions) => Promise<unknown> | void;
+    alias: (to: string, from?: string, options?: SegmentEventOptions) => Promise<unknown> | void;
+    reset: () => Promise<unknown> | void;
+    setAnonymousId: (id: string) => Promise<unknown> | void;
+}
+/**
+ * Segment event options — the fourth argument to track/identify/group/page
+ * that carries context and integration overrides. The destination uses
+ * this to stamp consent context on every event.
+ */
+interface SegmentEventOptions {
+    context?: {
+        consent?: {
+            categoryPreferences?: Record<string, boolean>;
+        };
+        [key: string]: unknown;
+    };
+    integrations?: Record<string, boolean | Record<string, unknown>>;
+}
+/**
+ * The module namespace used for `env?.analytics ?? realSegment`.
+ * AnalyticsBrowser is the class; tests mock with a factory that returns
+ * an object matching SegmentAnalytics.
+ *
+ * Task 1 verified: `AnalyticsBrowser.load(settings, options)` returns an
+ * `AnalyticsBrowser` instance **synchronously**. The instance buffers
+ * method calls until the internal load promise resolves.
+ */
+interface SegmentSDK {
+    load: (settings: AnalyticsBrowserSettings, options?: InitOptions) => SegmentAnalytics;
+}
+/**
+ * Env — optional SDK override. Production leaves this undefined and the
+ * destination falls back to the real @segment/analytics-next module.
+ * Tests provide a mock via env.analytics = { ... }.
+ */
+interface Env extends DestinationWeb.Env {
+    analytics?: SegmentSDK;
+}
+
+declare const init: Env | undefined;
+declare const push: Env;
+/** Simulation tracking paths for CLI --simulate. */
+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 carry destination-level settings.
+ * The test runner merges this on top of a base { apiKey: 'test-project' }.
+ */
+type SegmentStepExample = Flow.StepExample & {
+    settings?: Partial<Settings>;
+    configInclude?: string[];
+};
+/**
+ * Default event forwarding — every walkerOS event becomes
+ * analytics.track(event.name, properties). With no mapping and no
+ * destination-level include, properties is `{}`.
+ */
+declare const defaultEventForwarding: SegmentStepExample;
+/**
+ * Wildcard ignore — walkerOS's standard way to drop events. The rule
+ * matches but does nothing. The destination fires zero SDK calls.
+ */
+declare const wildcardIgnored: SegmentStepExample;
+/**
+ * Destination-level settings.include flattens the walkerOS `data` section
+ * into prefixed properties on every push.
+ */
+declare const destinationLevelInclude: SegmentStepExample;
+/**
+ * Per-rule settings.include REPLACES destination-level include for the
+ * matched rule. Here destination-level sends `data`, but the rule
+ * overrides it with `globals` only.
+ */
+declare const ruleIncludeReplaces: SegmentStepExample;
+/**
+ * Destination-level settings.identify fires on the first push. The
+ * destination resolves the mapping, calls analytics.identify(userId),
+ * and records the value in runtime state. Subsequent pushes with the
+ * same userId do NOT re-fire identify().
+ */
+declare const destinationLevelIdentify: SegmentStepExample;
+/**
+ * Per-event identify with traits — the canonical "user login" pattern.
+ * skip: true suppresses the default analytics.track() call because we're
+ * running identity side effects only. Matches Segment Spec reserved traits
+ * (email, name, plan, company) so downstream destinations recognize them.
+ */
+declare const userLoginIdentify: SegmentStepExample;
+/**
+ * Profile update — omit userId. Segment's SDK uses the currently stored
+ * userId and merges the traits into the existing trait set.
+ */
+declare const profileUpdateTraitsOnly: SegmentStepExample;
+/**
+ * User logout — reset: true fires analytics.reset(), which clears userId,
+ * anonymousId, traits, and generates a new anonymous ID.
+ * skip: true because we're only running the reset side effect.
+ */
+declare const userLogoutReset: SegmentStepExample;
+/**
+ * Per-event group assignment — company update event attaches the user
+ * to a company and sets the company's traits in one call.
+ */
+declare const companyUpdateGroup: SegmentStepExample;
+/**
+ * Explicit page() call — the canonical Segment pattern for page views.
+ * skip: true suppresses the default track() call; settings.page fires
+ * analytics.page(category, name, properties) instead.
+ */
+declare const pageViewAsPage: SegmentStepExample;
+/**
+ * Minimal page() call — settings.page: true produces an empty
+ * analytics.page() relying entirely on SDK auto-collection.
+ */
+declare const pageViewMinimal: SegmentStepExample;
+/**
+ * Segment ecommerce spec — Order Completed event. One track() call with
+ * a products array. Uses mapping.name to produce the Segment Spec name
+ * and mapping.data to build the properties object including the nested
+ * products loop. The loop filters via condition to products with prices.
+ */
+declare const orderCompletedEcommerce: SegmentStepExample;
+/**
+ * Consent context forwarding — when the event has consent state,
+ * the destination automatically stamps every track/identify/group/page
+ * call with context.consent.categoryPreferences. settings.consent
+ * remaps walkerOS keys to Segment category names.
+ */
+declare const consentContextForwarded: SegmentStepExample;
+/**
+ * Consent granted → deferred load fires for the first time. The
+ * destination was initialized with consent requirement; on the walker
+ * consent command it calls analytics.load(writeKey, initOptions).
+ *
+ * Uses the canonical StepExample.command='consent' pattern. The full
+ * call shape includes both the settings arg and the initOptions arg.
+ */
+declare const consentGrantDeferredLoad: SegmentStepExample;
+/**
+ * Consent revoked → no SDK call. The walkerOS consent gate handles
+ * blocking subsequent events. The destination's on('consent') handler
+ * is a no-op on revocation (Segment has no opt-out method).
+ */
+declare const consentRevokeNoOp: SegmentStepExample;
+
+type step_SegmentStepExample = SegmentStepExample;
+declare const step_companyUpdateGroup: typeof companyUpdateGroup;
+declare const step_consentContextForwarded: typeof consentContextForwarded;
+declare const step_consentGrantDeferredLoad: typeof consentGrantDeferredLoad;
+declare const step_consentRevokeNoOp: typeof consentRevokeNoOp;
+declare const step_defaultEventForwarding: typeof defaultEventForwarding;
+declare const step_destinationLevelIdentify: typeof destinationLevelIdentify;
+declare const step_destinationLevelInclude: typeof destinationLevelInclude;
+declare const step_orderCompletedEcommerce: typeof orderCompletedEcommerce;
+declare const step_pageViewAsPage: typeof pageViewAsPage;
+declare const step_pageViewMinimal: typeof pageViewMinimal;
+declare const step_profileUpdateTraitsOnly: typeof profileUpdateTraitsOnly;
+declare const step_ruleIncludeReplaces: typeof ruleIncludeReplaces;
+declare const step_userLoginIdentify: typeof userLoginIdentify;
+declare const step_userLogoutReset: typeof userLogoutReset;
+declare const step_wildcardIgnored: typeof wildcardIgnored;
+declare namespace step {
+  export { type step_SegmentStepExample as SegmentStepExample, step_companyUpdateGroup as companyUpdateGroup, step_consentContextForwarded as consentContextForwarded, step_consentGrantDeferredLoad as consentGrantDeferredLoad, step_consentRevokeNoOp as consentRevokeNoOp, step_defaultEventForwarding as defaultEventForwarding, step_destinationLevelIdentify as destinationLevelIdentify, step_destinationLevelInclude as destinationLevelInclude, step_orderCompletedEcommerce as orderCompletedEcommerce, step_pageViewAsPage as pageViewAsPage, step_pageViewMinimal as pageViewMinimal, step_profileUpdateTraitsOnly as profileUpdateTraitsOnly, step_ruleIncludeReplaces as ruleIncludeReplaces, step_userLoginIdentify as userLoginIdentify, step_userLogoutReset as userLogoutReset, step_wildcardIgnored as wildcardIgnored };
+}
+
+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 };