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

package/dist/dev.d.ts

@@ -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 };