@walkeros/web-destination-amplitude 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,273 @@
+<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>
+
+# Amplitude Destination for walkerOS
+
+[Source Code](https://github.com/elbwalker/walkerOS/tree/main/packages/web/destinations/amplitude)
+&bull;
+[NPM Package](https://www.npmjs.com/package/@walkeros/web-destination-amplitude)
+&bull; [Documentation](https://www.walkeros.io/docs/destinations/web/amplitude)
+
+This package forwards walkerOS events to [Amplitude](https://amplitude.com/) —
+product analytics with identity, revenue, groups, and optional session replay,
+experiments, and guides & surveys. Built on the official
+[`@amplitude/unified`](https://www.npmjs.com/package/@amplitude/unified) SDK
+which bundles analytics, session replay, experiments, and engagement.
+
+walkerOS follows a **source → collector → destination** architecture. This
+Amplitude destination receives processed events from the walkerOS collector and
+forwards them as Amplitude track, identify, revenue, group, and consent calls.
+
+## Features
+
+- **Default event forwarding** — every walkerOS event becomes
+  `amplitude.track(name, event_properties)` with no additional config
+- **Custom event properties** — flatten walkerOS event sections
+  (`settings.include`) or map freely via the standard walkerOS `mapping.data`
+  DSL
+- **Identity** — destination-level and per-event `settings.identify` with the
+  full Amplitude operation vocabulary (`set`, `setOnce`, `add`, `append`,
+  `prepend`, `preInsert`, `postInsert`, `remove`, `unset`, `clearAll`). Runtime
+  state diffing skips redundant setter calls.
+- **Revenue** — `settings.revenue` supports both single-object and `loop`-based
+  multi-product orders. Currency defaults to `"EUR"`.
+- **Groups** — `settings.group` and `settings.groupIdentify` for B2B flows
+- **Consent** — `on('consent')` handler derives the consent keys from
+  `config.consent` and toggles `amplitude.setOptOut()`
+- **Optional plugins** (all npm-bundled via `@amplitude/unified`, opt-in via
+  settings): Session Replay, Feature Experiments, Engagement (Guides & Surveys)
+- **Async init** — awaits `amplitude.initAll(...)` so downstream pushes are
+  truly ready before returning
+
+> **Bundle cost:** All three plugin packages are statically imported and
+> therefore bundled even when not configured. Expect an additional ~135 KB from
+> Session Replay plus the Experiment and Engagement payloads.
+
+## Installation
+
+```sh
+npm install @walkeros/web-destination-amplitude
+```
+
+## Quick Start
+
+```typescript
+import { startFlow } from '@walkeros/collector';
+import { destinationAmplitude } from '@walkeros/web-destination-amplitude';
+
+await startFlow({
+  destinations: {
+    amplitude: {
+      code: destinationAmplitude,
+      config: {
+        consent: { analytics: true },
+        settings: {
+          apiKey: 'YOUR_AMPLITUDE_API_KEY',
+        },
+      },
+    },
+  },
+});
+```
+
+## Configuration
+
+### Settings (destination-level)
+
+All fields of Amplitude's `BrowserOptions` pass through to
+`amplitude.init(apiKey, options)`. walkerOS-specific additions:
+
+| Name            | Type                                 | Description                                                                                                                               | Required |
+| --------------- | ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------- | -------- |
+| `apiKey`        | `string`                             | Your Amplitude project API key                                                                                                            | Yes      |
+| `identify`      | `Mapping.Value`                      | Destination-level identity mapping; see Identity section                                                                                  | No       |
+| `include`       | `string[]`                           | walkerOS event sections to flatten into `event_properties` (`data`, `globals`, `context`, `user`, `source`, `version`, `event`, or `all`) | No       |
+| `sessionReplay` | `SessionReplayOptions`               | If set, enables session replay via `@amplitude/unified` with these options                                                                | No       |
+| `experiment`    | `ExperimentConfig` + `deploymentKey` | If `deploymentKey` set, configures the experiment plugin from `@amplitude/unified`                                                        | No       |
+| `engagement`    | `boolean \| InitOptions`             | Pass `true` for default Guides & Surveys plugin, or an options object                                                                     | No       |
+
+### Mapping (`rule.settings`)
+
+| Name            | Type                       | Description                                                                                                                                                                                                                        |
+| --------------- | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `identify`      | `Mapping.Value`            | Per-event identity; resolves to an object with any of `user`, `device`, `session`, `set`, `setOnce`, `add`, `append`, `prepend`, `preInsert`, `postInsert`, `remove`, `unset`, `clearAll`                                          |
+| `include`       | `string[]`                 | Overrides destination-level `include` for this rule                                                                                                                                                                                |
+| `revenue`       | `Mapping.Value`            | Resolves to a single object or (via `loop`) an array, each with `productId`, `price`, `quantity`, `revenueType`, `currency`, `revenue`, `receipt`, `receiptSig`, `eventProperties`. One `amplitude.revenue()` call fires per item. |
+| `group`         | `Mapping.Value`            | Resolves to `{ type, name }` → `amplitude.setGroup(type, name)`                                                                                                                                                                    |
+| `groupIdentify` | `Mapping.Value`            | Resolves to `{ type, name, set?, setOnce?, ... }` → `amplitude.groupIdentify(type, name, identify)`                                                                                                                                |
+| `reset`         | `boolean \| Mapping.Value` | Truthy → `amplitude.reset()` (logout). Typically paired with `skip: true`.                                                                                                                                                         |
+
+## Custom Event Properties
+
+```typescript
+// Flatten walkerOS sections onto every tracked event (prefixed).
+settings: {
+  apiKey: 'YOUR_KEY',
+  include: ['data', 'globals'],
+}
+// → amplitude.track('product view', { data_id: 'ers', data_price: 420, globals_pagegroup: 'shop' })
+```
+
+Per-rule override via `mapping.settings.include` replaces destination-level
+`include` for the matched rule.
+
+## Identity
+
+```typescript
+mapping: {
+  user: {
+    login: {
+      skip: true, // suppress default track()
+      settings: {
+        identify: {
+          map: {
+            user: 'data.user_id',
+            set: { map: { plan: 'data.plan', email: 'data.email' } },
+            setOnce: { map: { first_login: 'timestamp' } },
+            add: { map: { login_count: { value: 1 } } },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+- `user` → `amplitude.setUserId(...)` (with state diffing)
+- `device` → `amplitude.setDeviceId(...)`
+- `session` → `amplitude.setSessionId(...)` (numeric strings parse; other
+  strings are deterministically hashed via djb2 for cross-page-load consistency)
+- The remaining operation keys are forwarded through `amplitude.Identify` and
+  `amplitude.identify(...)`
+
+## Revenue
+
+```typescript
+// Single-product renewal
+mapping: {
+  subscription: {
+    renew: {
+      skip: true,
+      settings: {
+        revenue: {
+          map: {
+            productId: 'data.plan_id',
+            price: 'data.amount',
+            revenueType: { value: 'renewal' },
+            currency: { key: 'data.currency', value: 'EUR' },
+          },
+        },
+      },
+    },
+  },
+}
+
+// Multi-product order via loop
+mapping: {
+  order: {
+    complete: {
+      settings: {
+        include: ['data'],
+        revenue: {
+          loop: ['nested', {
+            condition: (v) => typeof v?.data?.price === 'number',
+            map: {
+              productId: 'data.id',
+              price: 'data.price',
+              quantity: { key: 'data.quantity', value: 1 },
+              revenueType: { value: 'purchase' },
+              currency: { key: 'data.currency', value: 'EUR' },
+            },
+          }],
+        },
+      },
+    },
+  },
+}
+```
+
+Every item from the loop becomes its own `amplitude.revenue()` call; the default
+`track()` still fires once for the order-level event.
+
+## Groups
+
+```typescript
+settings: {
+  group: {
+    map: { type: { value: 'company' }, name: 'data.company' },
+  },
+  groupIdentify: {
+    map: {
+      type: { value: 'company' },
+      name: 'data.company',
+      set: { map: { industry: 'data.industry' } },
+    },
+  },
+}
+// → amplitude.setGroup('company', 'Acme')
+// → amplitude.groupIdentify('company', 'Acme', identify)
+```
+
+## Reset (Logout)
+
+```typescript
+mapping: {
+  user: {
+    logout: {
+      skip: true,
+      settings: { reset: true },
+    },
+  },
+}
+// → amplitude.reset()
+```
+
+Clears the Amplitude user ID and regenerates a device ID. The destination also
+clears its runtime identity cache so the next push re-fires the setters.
+
+## Consent
+
+Declare the required consent keys on the destination config, then push a walker
+consent event — the destination's `on('consent')` handler toggles
+`amplitude.setOptOut()` accordingly. Semantics are strict: all required keys
+must be granted for opt-in; any missing grant opts out.
+
+```typescript
+config: {
+  consent: { analytics: true }, // required consent keys
+  settings: { apiKey: 'YOUR_KEY' },
+}
+// elb('walker consent', { analytics: false }) → amplitude.setOptOut(true)
+// elb('walker consent', { analytics: true  }) → amplitude.setOptOut(false)
+```
+
+## Plugins
+
+All three plugins are bundled via `@amplitude/unified` and opt-in via
+destination settings:
+
+```typescript
+settings: {
+  apiKey: 'YOUR_KEY',
+
+  // Session Replay
+  sessionReplay: { sampleRate: 1 },
+
+  // Feature Experiments (via @amplitude/unified)
+  experiment: { deploymentKey: 'DEPLOYMENT_KEY' },
+
+  // Guides & Surveys (true for defaults, object for custom)
+  engagement: true,
+}
+```
+
+## Related
+
+- [walkerOS documentation](https://www.walkeros.io/docs)
+- [Amplitude Browser SDK docs](https://amplitude.com/docs/sdks/analytics/browser/browser-sdk-2)
+- [Amplitude Session Replay](https://amplitude.com/docs/session-replay)
+- [Amplitude Experiment](https://amplitude.com/docs/experiment)
+- [Amplitude Guides & Surveys](https://amplitude.com/docs/guides-and-surveys)

package/dist/dev.d.mts

@@ -0,0 +1,289 @@
+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 { Types } from '@amplitude/unified';
+import { SessionReplayOptions } from '@amplitude/plugin-session-replay-browser';
+import { ExperimentPluginConfig } from '@amplitude/plugin-experiment-browser';
+import { InitOptions } from '@amplitude/engagement-browser';
+
+declare const SettingsSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+    serverZone: z.ZodOptional<z.ZodEnum<{
+        US: "US";
+        EU: "EU";
+    }>>;
+    flushIntervalMillis: z.ZodOptional<z.ZodNumber>;
+    flushQueueSize: z.ZodOptional<z.ZodNumber>;
+    flushMaxRetries: z.ZodOptional<z.ZodNumber>;
+    transport: z.ZodOptional<z.ZodEnum<{
+        fetch: "fetch";
+        xhr: "xhr";
+        beacon: "beacon";
+    }>>;
+    useBatch: z.ZodOptional<z.ZodBoolean>;
+    appVersion: z.ZodOptional<z.ZodString>;
+    identify: z.ZodOptional<z.ZodUnknown>;
+    sessionReplay: z.ZodOptional<z.ZodUnknown>;
+    experiment: z.ZodOptional<z.ZodUnknown>;
+    engagement: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+type Settings$1 = z.infer<typeof SettingsSchema>;
+
+declare const MappingSchema: z.ZodObject<{
+    identify: z.ZodOptional<z.ZodUnknown>;
+    revenue: z.ZodOptional<z.ZodUnknown>;
+    group: z.ZodOptional<z.ZodUnknown>;
+    groupIdentify: 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 };
+}
+
+type BrowserOptions = Omit<Types.BrowserOptions, 'identify'>;
+/**
+ * Destination-level settings.
+ *
+ * All Amplitude `BrowserOptions` are passthrough init options — extending the
+ * SDK type directly keeps IntelliSense complete and prevents drift. The
+ * destination adds:
+ *  - `apiKey` (required) — first arg to `amplitude.init(...)`
+ *  - `identify` — destination-level identity mapping
+ *  - `sessionReplay` / `experiment` / `engagement` — optional plugin configs
+ *  - `_state` — runtime state (not user-facing, mutated by init/push)
+ */
+interface Settings extends BrowserOptions {
+    apiKey: string;
+    identify?: Mapping$1.Value;
+    sessionReplay?: SessionReplayOptions;
+    experiment?: ExperimentPluginConfig & {
+        deploymentKey: string;
+    };
+    engagement?: boolean | InitOptions;
+    /** Runtime state — populated by init() and mutated by push(). Not user-facing. */
+    _state?: RuntimeState;
+}
+interface RuntimeState {
+    /** Last-set identity values, used to skip redundant setUserId/setDeviceId/setSessionId calls. */
+    lastIdentity?: {
+        user?: string;
+        device?: string;
+        session?: number;
+    };
+}
+/**
+ * Amplitude SDK surface — the subset of @amplitude/unified the
+ * destination actually uses. Mirrors the real module's named exports so
+ * tests can mock each method individually via env.amplitude.
+ */
+interface AmplitudeSDK {
+    initAll: (apiKey: string, options?: Record<string, unknown>) => Promise<void>;
+    track: (eventType: string, eventProperties?: Record<string, unknown>) => void;
+    identify: (identify: IdentifyInstance) => void;
+    revenue: (revenue: RevenueInstance) => void;
+    reset: () => void;
+    setOptOut: (optOut: boolean) => void;
+    setUserId: (userId: string | undefined) => void;
+    setDeviceId: (deviceId: string) => void;
+    setSessionId: (sessionId: number) => void;
+    setGroup: (groupType: string, groupName: string | string[]) => void;
+    groupIdentify: (groupType: string, groupName: string, identify: IdentifyInstance) => void;
+    flush: () => {
+        promise: Promise<void>;
+    };
+    add: (plugin: unknown) => {
+        promise: Promise<void>;
+    };
+    Identify: new () => IdentifyInstance;
+    Revenue: new () => RevenueInstance;
+}
+/** Chainable Identify — mirrors @amplitude/unified Identify class. */
+interface IdentifyInstance {
+    set: (property: string, value: unknown) => IdentifyInstance;
+    setOnce: (property: string, value: unknown) => IdentifyInstance;
+    add: (property: string, value: number) => IdentifyInstance;
+    append: (property: string, value: unknown) => IdentifyInstance;
+    prepend: (property: string, value: unknown) => IdentifyInstance;
+    preInsert: (property: string, value: unknown) => IdentifyInstance;
+    postInsert: (property: string, value: unknown) => IdentifyInstance;
+    remove: (property: string, value: unknown) => IdentifyInstance;
+    unset: (property: string) => IdentifyInstance;
+    clearAll: () => IdentifyInstance;
+}
+/** Chainable Revenue — mirrors @amplitude/unified Revenue class. */
+interface RevenueInstance {
+    setProductId: (id: string) => RevenueInstance;
+    setPrice: (price: number) => RevenueInstance;
+    setQuantity: (quantity: number) => RevenueInstance;
+    setRevenueType: (type: string) => RevenueInstance;
+    setCurrency: (currency: string) => RevenueInstance;
+    setRevenue: (revenue: number) => RevenueInstance;
+    setReceipt: (receipt: string) => RevenueInstance;
+    setReceiptSig: (signature: string) => RevenueInstance;
+    setEventProperties: (properties: Record<string, unknown>) => RevenueInstance;
+}
+/**
+ * Env — optional SDK override. Production leaves this undefined and the
+ * destination falls back to the real @amplitude/unified module
+ * import. Tests provide a mock via env.amplitude = { ... }.
+ */
+interface Env extends DestinationWeb.Env {
+    amplitude?: AmplitudeSDK;
+}
+
+/**
+ * Pre-init env — all methods are no-ops until the test runner wires spies.
+ */
+declare const init: Env | undefined;
+/**
+ * Post-init env — same shape. The test runner clones this and replaces
+ * individual methods with jest.fn() so it can assert on calls.
+ */
+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 and/or an
+ * `await` hint for async scenarios. The test runner reads `settings`
+ * from the example and merges it into the base destination settings
+ * on top of the fixed apiKey. `configInclude` is passed as config-level
+ * include when registering the destination.
+ */
+type AmplitudeStepExample = Flow.StepExample & {
+    settings?: Partial<Settings>;
+    configInclude?: string[];
+};
+/**
+ * Default event forwarding — every walkerOS event becomes
+ * amplitude.track(event.name, event_properties). With no mapping and
+ * no destination-level include, event_properties is `{}`.
+ */
+declare const defaultEventForwarding: AmplitudeStepExample;
+/**
+ * Wildcard ignore — walkerOS's standard way to drop events. The rule
+ * matches but does nothing. The destination fires zero SDK calls.
+ */
+declare const wildcardIgnored: AmplitudeStepExample;
+/**
+ * Destination-level settings.include flattens the walkerOS `data` section
+ * into prefixed event_properties on every push.
+ */
+declare const destinationLevelInclude: AmplitudeStepExample;
+/**
+ * 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: AmplitudeStepExample;
+/**
+ * Destination-level settings.identify fires on the first push (once the
+ * state cache is empty). The destination sets user/device/session IDs
+ * and tracks them in runtime state; subsequent pushes with unchanged
+ * values do NOT re-fire the setters.
+ *
+ * This example represents the first push in a fresh session. user.id,
+ * user.device, user.session come from the walkerOS session fixture.
+ *
+ * The walkerOS fixture's user.session is 's3ss10n' (string). The
+ * destination deterministically hashes non-numeric session strings via
+ * djb2 so the same walkerOS session always maps to the same Amplitude
+ * session number (cross-page-load consistency). djb2('s3ss10n') = 394324160.
+ */
+declare const destinationLevelIdentify: AmplitudeStepExample;
+/**
+ * Per-event identify with the full operation vocabulary — this is the
+ * "user login" pattern: set user_id, enrich user properties. `skip: true`
+ * suppresses the default amplitude.track() call because we're running
+ * identity side effects only.
+ */
+declare const userLoginIdentify: AmplitudeStepExample;
+/**
+ * User logout — reset: true fires amplitude.reset(), which clears userId
+ * and regenerates deviceId. `skip: true` because we're only running the
+ * reset side effect, no default track().
+ */
+declare const userLogoutReset: AmplitudeStepExample;
+/**
+ * Single-product revenue — resolves `settings.revenue` to one object and
+ * fires one amplitude.revenue() call. Note the `{ key: "data.currency",
+ * value: "EUR" }` fallback syntax: try data.currency, default to "EUR".
+ *
+ * The walkerOS default event has no data.currency, so the fallback fires.
+ */
+declare const subscriptionRenewRevenue: AmplitudeStepExample;
+/**
+ * Multi-product order — the canonical Amplitude ecommerce pattern.
+ * `revenue.loop: ["nested", { map: ... }]` iterates event.nested and
+ * resolves one revenue item per entry. Each becomes a separate
+ * amplitude.revenue() call. The order-level track() fires once with
+ * include-based event_properties.
+ *
+ * The default "order complete" fixture has 3 nested entries: two
+ * products (ers, cc) and one gift. Products have `data.price`; the
+ * gift has only `data.name`. The `condition` on the loop inner value
+ * filters to products only (price must be present).
+ */
+declare const orderCompleteMultiProduct: AmplitudeStepExample;
+/**
+ * Group assignment + group properties. Typically used for B2B products
+ * where a user belongs to a company. Both SDK calls fire on the same rule.
+ */
+declare const groupAssignmentWithProperties: AmplitudeStepExample;
+/**
+ * Consent revoked → amplitude.setOptOut(true). The destination checks
+ * the consent keys declared in config.consent and toggles optOut
+ * accordingly (strict: all required keys must be granted).
+ *
+ * Uses the canonical StepExample.command='consent' pattern: the test
+ * runner dispatches via elb('walker consent', in) instead of pushing
+ * an event.
+ */
+declare const consentRevokeOptOut: AmplitudeStepExample;
+/**
+ * Consent granted → amplitude.setOptOut(false).
+ */
+declare const consentGrantOptIn: AmplitudeStepExample;
+
+type step_AmplitudeStepExample = AmplitudeStepExample;
+declare const step_consentGrantOptIn: typeof consentGrantOptIn;
+declare const step_consentRevokeOptOut: typeof consentRevokeOptOut;
+declare const step_defaultEventForwarding: typeof defaultEventForwarding;
+declare const step_destinationLevelIdentify: typeof destinationLevelIdentify;
+declare const step_destinationLevelInclude: typeof destinationLevelInclude;
+declare const step_groupAssignmentWithProperties: typeof groupAssignmentWithProperties;
+declare const step_orderCompleteMultiProduct: typeof orderCompleteMultiProduct;
+declare const step_ruleIncludeReplaces: typeof ruleIncludeReplaces;
+declare const step_subscriptionRenewRevenue: typeof subscriptionRenewRevenue;
+declare const step_userLoginIdentify: typeof userLoginIdentify;
+declare const step_userLogoutReset: typeof userLogoutReset;
+declare const step_wildcardIgnored: typeof wildcardIgnored;
+declare namespace step {
+  export { type step_AmplitudeStepExample as AmplitudeStepExample, step_consentGrantOptIn as consentGrantOptIn, step_consentRevokeOptOut as consentRevokeOptOut, step_defaultEventForwarding as defaultEventForwarding, step_destinationLevelIdentify as destinationLevelIdentify, step_destinationLevelInclude as destinationLevelInclude, step_groupAssignmentWithProperties as groupAssignmentWithProperties, step_orderCompleteMultiProduct as orderCompleteMultiProduct, step_ruleIncludeReplaces as ruleIncludeReplaces, step_subscriptionRenewRevenue as subscriptionRenewRevenue, 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 };