@walkeros/web-destination-posthog 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,308 @@
+<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>
+
+# PostHog Destination for walkerOS
+
+[Source Code](https://github.com/elbwalker/walkerOS/tree/main/packages/web/destinations/posthog)
+&bull;
+[NPM Package](https://www.npmjs.com/package/@walkeros/web-destination-posthog)
+&bull; [Documentation](https://www.walkeros.io/docs/destinations/web/posthog)
+
+This package forwards walkerOS events to [PostHog](https://posthog.com/) —
+product analytics, session replay, feature flags, surveys, and heatmaps. Built
+on the official [`posthog-js`](https://www.npmjs.com/package/posthog-js) SDK.
+
+walkerOS follows a **source → collector → destination** architecture. This
+PostHog destination receives processed events from the walkerOS collector and
+forwards them as PostHog captures, identifies, group assignments, and consent
+updates. All built-in PostHog features (session replay, feature flags, surveys,
+heatmaps, exception capture) are available through SDK init passthrough — no
+destination-specific plugins required.
+
+## Features
+
+- **Default event forwarding** — every walkerOS event becomes
+  `posthog.capture(event.name, properties)` with no additional config
+- **Custom event properties** — flatten walkerOS event sections via
+  `settings.include` (prefixed as `data_*`, `globals_*`, etc.)
+- **Identity** — destination-level and per-event identity mapping resolving to
+  `{ distinctId?, $set?, $set_once? }`. With `distinctId`: `posthog.identify()`.
+  Without `distinctId`: `posthog.setPersonProperties()` for pure person-property
+  updates. Runtime state diffing skips redundant identify calls when the
+  resolved values have not changed.
+- **Groups** — B2B-style group analytics via `settings.group`; resolves to
+  `{ type, key, properties? }` and calls `posthog.group(...)`
+- **Logout** — `reset: true` triggers `posthog.reset()` to clear the distinct ID
+  and regenerate an anonymous one
+- **Consent** — declares required consent keys via `config.consent`; a
+  `walker consent` event with all required keys granted calls
+  `posthog.opt_in_capturing()`, otherwise `posthog.opt_out_capturing()`
+- **Built-in PostHog features as config passthrough** — session replay
+  (`session_recording`), feature flags (`bootstrap`, `advanced_disable_flags`),
+  surveys (`disable_surveys`), heatmaps (`capture_heatmaps`), exception capture
+  (`capture_exceptions`), cookieless mode (`cookieless_mode`). All
+  `PostHogConfig` fields pass through unchanged.
+
+## Installation
+
+```sh
+npm install @walkeros/web-destination-posthog
+```
+
+## Quick Start
+
+```typescript
+import { startFlow } from '@walkeros/collector';
+import { destinationPostHog } from '@walkeros/web-destination-posthog';
+
+await startFlow({
+  destinations: {
+    posthog: {
+      code: destinationPostHog,
+      config: {
+        settings: {
+          apiKey: 'phc_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
+          api_host: 'https://eu.i.posthog.com', // or us.i.posthog.com
+        },
+      },
+    },
+  },
+});
+```
+
+## Configuration
+
+### Settings (destination-level)
+
+| Name       | Type            | Description                                                                                        | Required |
+| ---------- | --------------- | -------------------------------------------------------------------------------------------------- | -------- |
+| `apiKey`   | `string`        | PostHog project API key (starts with `phc_`)                                                       | Yes      |
+| `api_host` | `string`        | PostHog ingestion host. Default `https://us.i.posthog.com`. Use `https://eu.i.posthog.com` for EU. | No       |
+| `include`  | `string[]`      | walkerOS event sections to flatten into `capture()` properties (`data`, `globals`, `context`, …)   | No       |
+| `identify` | `Mapping.Value` | Destination-level identity mapping; resolves to `{ distinctId?, $set?, $set_once? }`               | No       |
+| `group`    | `Mapping.Value` | Destination-level group assignment; resolves to `{ type, key, properties? }`                       | No       |
+
+All other [`PostHogConfig`](https://posthog.com/docs/libraries/js#config) fields
+(e.g. `session_recording`, `capture_heatmaps`, `bootstrap`, `cookieless_mode`)
+pass through unchanged. walkerOS sets three defaults that differ from PostHog's
+built-ins: `autocapture: false`, `capture_pageview: false`,
+`capture_pageleave: false` — because walkerOS sources handle event capture.
+Override them explicitly in `settings` if you want PostHog's autocapture on.
+
+### Mapping (`rule.settings`)
+
+| Name       | Type                       | Description                                                                           |
+| ---------- | -------------------------- | ------------------------------------------------------------------------------------- |
+| `identify` | `Mapping.Value`            | Per-event identity. Resolves to `{ distinctId?, $set?, $set_once? }`                  |
+| `include`  | `string[]`                 | Override destination-level `include` for this rule                                    |
+| `group`    | `Mapping.Value`            | Per-event group assignment. Resolves to `{ type, key, properties? }`                  |
+| `reset`    | `Mapping.Value \| boolean` | Logout trigger. Truthy value → `posthog.reset()`. Typically paired with `skip: true`. |
+
+## Custom Event Properties
+
+Two ways to attach properties to a PostHog capture:
+
+```typescript
+// 1. Flatten walkerOS sections with settings.include
+config: {
+  settings: {
+    apiKey: 'phc_...',
+    include: ['data', 'globals'], // → data_*, globals_* on every event
+  },
+}
+
+// 2. Override per-rule via mapping.settings.include
+mapping: {
+  order: {
+    complete: {
+      settings: {
+        include: ['data', 'globals'], // EUR currency, totals, pagegroup
+      },
+    },
+  },
+}
+```
+
+PostHog has no dedicated revenue API — revenue events are regular `capture()`
+calls with the revenue properties in the payload. Use `include: ['data']` on an
+`order complete` rule to forward `data_total`, `data_currency` (e.g. `"EUR"`),
+`data_shipping`, etc.
+
+## Identity
+
+Destination-level identify fires on the first push and re-fires only when the
+resolved `distinctId` changes (runtime state diffing, skip redundant calls):
+
+```typescript
+settings: {
+  apiKey: 'phc_...',
+  identify: {
+    map: {
+      distinctId: 'user.id',
+    },
+  },
+}
+```
+
+Per-event identify supports the full PostHog vocabulary — `distinctId`, `$set`
+(person properties), `$set_once` (set-if-unset person properties). The
+destination calls `posthog.identify(distinctId, $set, $set_once)`:
+
+```typescript
+mapping: {
+  user: {
+    login: {
+      skip: true, // side-effect only, no capture() for user login
+      settings: {
+        identify: {
+          map: {
+            distinctId: 'data.user_id',
+            $set: {
+              map: {
+                email: 'data.email',
+                plan: 'data.plan',
+              },
+            },
+            $set_once: {
+              map: { first_login: 'timestamp' },
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+**Person properties without identity change.** When the resolved identify object
+has no `distinctId`, the destination calls
+`posthog.setPersonProperties($set, $set_once)` instead — useful for profile
+updates that should not create a new identity:
+
+```typescript
+mapping: {
+  profile: {
+    update: {
+      settings: {
+        identify: {
+          map: {
+            $set: { map: { name: 'data.name' } },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+## Groups
+
+PostHog's group analytics (Scale/Enterprise) aggregates events by company, team,
+or any custom group type. Configure a group mapping at destination or rule level
+— the destination calls `posthog.group(type, key, properties?)`:
+
+```typescript
+mapping: {
+  company: {
+    update: {
+      skip: true,
+      settings: {
+        group: {
+          map: {
+            type: { value: 'company' },
+            key: 'data.company_id',
+            properties: {
+              map: {
+                name: 'data.company_name',
+                plan: 'data.plan',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+## Logout
+
+`reset: true` (or any truthy mapping value) calls `posthog.reset()`, clearing
+the distinct ID and generating a new anonymous one. Pair with `skip: true` so
+the rule runs as a pure side effect:
+
+```typescript
+mapping: {
+  user: {
+    logout: {
+      skip: true,
+      settings: { reset: true },
+    },
+  },
+}
+```
+
+## Consent
+
+Declare the required consent keys on the destination via `config.consent`. A
+`walker consent` event triggers the destination's `on('consent')` handler, which
+checks every declared key against the event payload. If **all** required keys
+are `true`, the destination calls `posthog.opt_in_capturing()`. Otherwise it
+calls `posthog.opt_out_capturing()`, which stops capture, session replay, and
+survey rendering.
+
+```typescript
+destinations: {
+  posthog: {
+    code: destinationPostHog,
+    config: {
+      consent: { analytics: true }, // required keys
+      settings: { apiKey: 'phc_...' },
+    },
+  },
+}
+```
+
+Without `config.consent` the destination takes no action on consent changes; the
+walkerOS `config.consent` gate still blocks unconsented events from reaching the
+destination in the first place.
+
+## Built-in Features (Config Passthrough)
+
+All these PostHog features work via standard `posthog-js` init options — no
+destination wiring required:
+
+- **Session replay** —
+  `settings.session_recording: { maskAllInputs: true, ... }`
+- **Feature flags** — `settings.bootstrap: { featureFlags: {...} }` for SSR,
+  `settings.advanced_disable_flags: true` to disable entirely. Access flags
+  directly via the `posthog` singleton.
+- **Surveys** — automatic via the SDK; `settings.disable_surveys: true` opts out
+- **Heatmaps** — `settings.capture_heatmaps: true`
+- **Exception capture** — `settings.capture_exceptions: true`
+- **Cookieless mode** — `settings.cookieless_mode: 'always' | 'on_reject'`
+- **Person profiles** — `settings.person_profiles: 'identified_only'` (PostHog
+  default, privacy-friendly) or `'always'`
+
+For programmatic access to flags, surveys, or exception reporting, import the
+SDK singleton directly:
+
+```typescript
+import posthog from 'posthog-js';
+posthog.getFeatureFlag('my-flag');
+posthog.captureException(error);
+```
+
+## 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,269 @@
+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 { PostHogConfig, Properties } from 'posthog-js';
+
+declare const SettingsSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+    api_host: z.ZodOptional<z.ZodString>;
+    ui_host: z.ZodOptional<z.ZodString>;
+    persistence: z.ZodOptional<z.ZodEnum<{
+        "localStorage+cookie": "localStorage+cookie";
+        cookie: "cookie";
+        localStorage: "localStorage";
+        sessionStorage: "sessionStorage";
+        memory: "memory";
+    }>>;
+    person_profiles: z.ZodOptional<z.ZodEnum<{
+        always: "always";
+        never: "never";
+        identified_only: "identified_only";
+    }>>;
+    autocapture: z.ZodOptional<z.ZodBoolean>;
+    capture_pageview: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"history_change">]>>;
+    capture_pageleave: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"if_capture_pageview">]>>;
+    capture_heatmaps: z.ZodOptional<z.ZodBoolean>;
+    capture_exceptions: z.ZodOptional<z.ZodBoolean>;
+    disable_surveys: z.ZodOptional<z.ZodBoolean>;
+    disable_session_recording: z.ZodOptional<z.ZodBoolean>;
+    advanced_disable_flags: z.ZodOptional<z.ZodBoolean>;
+    cookieless_mode: z.ZodOptional<z.ZodEnum<{
+        always: "always";
+        on_reject: "on_reject";
+    }>>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+    session_recording: z.ZodOptional<z.ZodUnknown>;
+    bootstrap: z.ZodOptional<z.ZodUnknown>;
+    identify: z.ZodOptional<z.ZodUnknown>;
+    group: z.ZodOptional<z.ZodUnknown>;
+}, 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>;
+    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.
+ *
+ * PostHog's `PostHogConfig` interface has ~80 fields — extending the SDK type
+ * directly keeps IntelliSense complete and prevents drift. The destination adds:
+ *  - `apiKey` (required) — first arg to `posthog.init(...)`, NOT an init option
+ *  - `identify` — destination-level identity mapping
+ *  - `include` — event sections flattened into `capture()` properties
+ *  - `group` — destination-level group association
+ *  - `_state` — runtime state (not user-facing, mutated by init/push)
+ *
+ * All other walkerOS-specific mapping features live under mapping.settings
+ * (see Mapping interface below). Built-in PostHog features (session_recording,
+ * advanced_disable_flags, disable_surveys, capture_heatmaps, capture_exceptions,
+ * bootstrap, cookieless_mode, ...) are passthrough via PostHogConfig.
+ */
+interface Settings extends Partial<PostHogConfig> {
+    /** PostHog project API key (e.g. "phc_XXX"). First arg to posthog.init(). */
+    apiKey: string;
+    /** Destination-level identity mapping, resolved on first push. */
+    identify?: Mapping$1.Value;
+    /** Destination-level group association, resolved on first push. */
+    group?: Mapping$1.Value;
+    /** Runtime state — populated by init() and mutated by push(). Not user-facing. */
+    _state?: RuntimeState;
+}
+interface RuntimeState {
+    /** Last-resolved identity values, used to skip redundant identify/group calls. */
+    lastIdentity?: {
+        distinctId?: string;
+    };
+    lastGroup?: {
+        type?: string;
+        key?: string;
+    };
+}
+/**
+ * PostHog SDK surface — the subset of `posthog-js` the destination actually
+ * uses. Mirrors the real module's default singleton export shape. Tests mock
+ * via env.posthog to intercept every call.
+ */
+interface PostHogSDK {
+    init: (token: string, config?: Partial<PostHogConfig> & {
+        loaded?: (posthog: PostHogSDK) => void;
+    }, name?: string) => PostHogSDK;
+    capture: (eventName: string, properties?: Properties) => void;
+    identify: (distinctId?: string, userPropertiesToSet?: Properties, userPropertiesToSetOnce?: Properties) => void;
+    setPersonProperties: (userPropertiesToSet?: Properties, userPropertiesToSetOnce?: Properties) => void;
+    group: (groupType: string, groupKey: string, groupPropertiesToSet?: Properties) => void;
+    reset: (resetDeviceId?: boolean) => void;
+    opt_in_capturing: (options?: {
+        captureEventName?: string | null | false;
+        captureProperties?: Properties;
+    }) => void;
+    opt_out_capturing: () => void;
+}
+/**
+ * Env — optional SDK override. Production leaves this undefined and the
+ * destination falls back to the real `posthog-js` default export. Tests
+ * provide a mock via env.posthog = { ... }.
+ */
+interface Env extends DestinationWeb.Env {
+    posthog?: PostHogSDK;
+}
+
+/**
+ * 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.
+ * The test runner reads `settings` from the example and merges them
+ * into the base destination settings on top of the fixed apiKey.
+ */
+type PostHogStepExample = Flow.StepExample & {
+    settings?: Partial<Settings>;
+    configInclude?: string[];
+};
+/**
+ * Default event forwarding — every walkerOS event becomes
+ * posthog.capture(event.name, properties). With no mapping and no
+ * destination-level include, properties is `{}`.
+ */
+declare const defaultEventForwarding: PostHogStepExample;
+/**
+ * Wildcard ignore — walkerOS's standard way to drop events. The rule
+ * matches but does nothing. The destination fires zero SDK calls.
+ */
+declare const wildcardIgnored: PostHogStepExample;
+/**
+ * Destination-level settings.include flattens the walkerOS `data` section
+ * into prefixed capture() properties on every push.
+ */
+declare const destinationLevelInclude: PostHogStepExample;
+/**
+ * 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: PostHogStepExample;
+/**
+ * Destination-level settings.identify fires on the first push (once the
+ * state cache is empty). The destination calls posthog.identify() and
+ * tracks the resolved distinctId in runtime state; subsequent pushes
+ * with unchanged values do NOT re-fire identify().
+ *
+ * With NO $set/$set_once keys in the resolved object, posthog.identify
+ * is called with just the distinctId.
+ */
+declare const destinationLevelIdentify: PostHogStepExample;
+/**
+ * Per-event identify with the full PostHog identity vocabulary.
+ * This is the "user login" pattern: set a new distinctId and enrich
+ * person properties. `skip: true` suppresses the default posthog.capture()
+ * call because we're running identity side effects only.
+ *
+ * PostHog identify signature:
+ *   posthog.identify(distinctId, $set, $set_once)
+ */
+declare const userLoginIdentify: PostHogStepExample;
+/**
+ * Person-properties-only update — when the resolved identify object has
+ * NO `distinctId` key, the destination calls setPersonProperties($set, $set_once)
+ * instead of identify(). This is the "profile update" pattern: enrich
+ * user properties without changing identity.
+ *
+ * `skip` defaults to false here — we intentionally ALSO capture a
+ * "profile update" event so it shows up in PostHog's event stream.
+ */
+declare const profileUpdateSetPersonProperties: PostHogStepExample;
+/**
+ * User logout — reset: true fires posthog.reset(), which clears the
+ * distinct ID and generates a new anonymous one. `skip: true` because
+ * we're only running the reset side effect, no default capture().
+ */
+declare const userLogoutReset: PostHogStepExample;
+/**
+ * Group assignment + group properties. PostHog's group analytics (paid)
+ * aggregates events by company / team / project. The destination resolves
+ * `settings.group` to { type, key, properties? } and calls
+ * posthog.group(type, key, properties). `skip: true` keeps this a
+ * pure side-effect rule — no "company update" capture().
+ */
+declare const groupAssignmentWithProperties: PostHogStepExample;
+/**
+ * Order complete — PostHog has no dedicated revenue API. Revenue tracking
+ * is just a capture() call with the revenue properties in data. This
+ * example pairs `include: ["data", "globals"]` with a destination-level
+ * capture. The order total, shipping, currency, etc. all become
+ * data_* properties on the PostHog event.
+ */
+declare const orderCompleteWithInclude: PostHogStepExample;
+/**
+ * Consent revoked → posthog.opt_out_capturing(). The destination checks
+ * the consent key declared in config.consent (here "analytics") and
+ * toggles accordingly. opt_out_capturing() stops capture, session
+ * replay, AND survey rendering.
+ *
+ * Uses the canonical StepExample.command='consent' pattern: the test
+ * runner dispatches via elb('walker consent', in) instead of pushing
+ * an event.
+ */
+declare const consentRevokeOptOut: PostHogStepExample;
+/**
+ * Consent granted → posthog.opt_in_capturing(). Called without arguments
+ * by default (the SDK fires its own $opt_in event).
+ */
+declare const consentGrantOptIn: PostHogStepExample;
+
+type step_PostHogStepExample = PostHogStepExample;
+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_orderCompleteWithInclude: typeof orderCompleteWithInclude;
+declare const step_profileUpdateSetPersonProperties: typeof profileUpdateSetPersonProperties;
+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_PostHogStepExample as PostHogStepExample, 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_orderCompleteWithInclude as orderCompleteWithInclude, step_profileUpdateSetPersonProperties as profileUpdateSetPersonProperties, 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 };