@greatwait/contracts 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/endpoints.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "./zod.js";
 import { environmentKindSchema } from "./authority.js";
 import { evaluateCallbackUrl } from "./callback-safety.js";
 import { callbackSigningKeyIdSchema, endpointIdSchema, projectIdSchema, } from "./identifiers.js";
@@ -12,15 +12,22 @@ import { timestampSchema } from "./time.js";
  * a caller can use to widen that tuple: `project` and `environmentKind` are
  * display metadata, while every lookup is scoped by the verified principal.
  */
-export const CALLBACK_ENDPOINT_STATUSES = [
-    "pending",
-    "verified",
-    "disabled",
-];
+/**
+ * An endpoint is usable the moment it exists (W4-12). `active` is every
+ * endpoint that is not disabled; `disabled` stops delivery until
+ * `endpoints.enable` turns it back on. There is no state in between and
+ * nothing to prove.
+ */
+export const CALLBACK_ENDPOINT_STATUSES = ["active", "disabled"];
 export const callbackEndpointStatusSchema = z.enum(CALLBACK_ENDPOINT_STATUSES);
-export const CALLBACK_VERIFICATION_FAILURES = [
+/**
+ * Why an address could not be resolved or reached: the classification the
+ * DNS inspection at create and update, and the delivery egress, share. It
+ * was the verification-failure vocabulary until W4-12 removed verification;
+ * what remains is what those two paths can still observe.
+ */
+export const CALLBACK_EGRESS_FAILURES = [
     "address_forbidden",
-    "challenge_failed",
     "connection_failed",
     "dns_unresolved",
     "rate_limited",
@@ -29,51 +36,74 @@ export const CALLBACK_VERIFICATION_FAILURES = [
     "timed_out",
     "unexpected_status",
 ];
-export const callbackVerificationFailureSchema = z.enum(CALLBACK_VERIFICATION_FAILURES);
+export const callbackEgressFailureSchema = z.enum(CALLBACK_EGRESS_FAILURES);
 /**
  * A safety ceiling on retained endpoint records, independent of later
  * commercial plan limits. Disabled records remain readable for audit and count
  * toward it; changing that lifetime semantic needs a product decision.
  */
 export const CALLBACK_ENDPOINT_LIMIT_PER_ENVIRONMENT = 50;
-/** Verification egress is admitted through both buckets before DNS or fetch. */
-export const CALLBACK_VERIFICATION_RATE_LIMITS = {
+/**
+ * DNS inspection at create and update is admitted through both buckets
+ * before the first lookup, so an address a caller retypes cannot make this
+ * service resolve names without bound.
+ */
+export const CALLBACK_ADMISSION_RATE_LIMITS = {
     destinationPerMinute: 5,
     projectPerMinute: 20,
     windowSeconds: 60,
 };
-/** Total bytes a verification response may return before it is refused. */
-export const CALLBACK_VERIFICATION_RESPONSE_BYTES = 1_024;
-/** Total DNS + connect + response bound for one verification attempt. */
-export const CALLBACK_VERIFICATION_TIMEOUT_MILLISECONDS = 5_000;
 /** Longest period during which a receiver may accept current and next keys. */
 export const CALLBACK_SIGNING_KEY_ROTATION_OVERLAP_SECONDS = 86_400;
 export const callbackSigningKeysSchema = z.object({
     current: callbackSigningKeyIdSchema,
     next: z
         .object({
+        /** When a person confirmed their server accepts this next key. */
+        acknowledgedAt: timestampSchema.optional(),
         id: callbackSigningKeyIdSchema,
         overlapEndsAt: timestampSchema,
     })
         .optional(),
 });
+/**
+ * An endpoint's name: unique within its project and environment, compared
+ * exactly (W4-14, FXO-2255).
+ *
+ * Generated on save when nobody types one — the whole URL — because an
+ * endpoint appears in a dropdown, and two identical rows in a dropdown are
+ * two rows nobody can choose between. So a second endpoint at an address one
+ * already has is refused unless it is given a name of its own. **Case
+ * matters**: two webhook URLs differing only in the case of a token are two
+ * endpoints and both save unnamed; the cost, accepted knowingly, is that
+ * "Prod receiver" and "prod receiver" are both allowed. Deliberately unlike a
+ * project's name, which ignores case and spacing.
+ */
+export const callbackEndpointNameSchema = z
+    .string()
+    .trim()
+    .min(1, "must not be blank")
+    .max(2_048, "must be at most 2048 characters");
 /**
  * A metadata-only endpoint shape. The sealed signing secret has no public
- * field, so list/get/update/verify/disable cannot accidentally recover it.
+ * field, so list/get/update/disable/enable cannot accidentally recover it.
  */
 export const callbackEndpointSchema = z.object({
     createdAt: timestampSchema,
     disabledAt: timestampSchema.optional(),
     environmentKind: environmentKindSchema,
     id: endpointIdSchema,
-    lastVerificationAttemptAt: timestampSchema.optional(),
-    lastVerificationFailure: callbackVerificationFailureSchema.optional(),
+    /**
+     * The endpoint's name. Every endpoint written since W4-14 has one — its
+     * URL when none was given — and it is optional on the wire only so a row
+     * from before the column parses rather than fails.
+     */
+    name: callbackEndpointNameSchema.optional(),
     project: projectIdSchema,
     signingKeys: callbackSigningKeysSchema,
     status: callbackEndpointStatusSchema,
     updatedAt: timestampSchema,
     url: z.string().url(),
-    verifiedAt: timestampSchema.optional(),
     version: z.number().int().positive(),
 });
 export const callbackEndpointPageSchema = pageSchema(callbackEndpointSchema);
@@ -97,6 +127,27 @@ export const callbackEndpointRotatedSchema = z.object({
     secret: z.string().min(1),
     shownOnce: z.literal(true),
 });
+/** One signing key and the secret behind it, as a signed-in person may see it. */
+export const callbackEndpointSigningSecretSchema = z.object({
+    keyId: callbackSigningKeyIdSchema,
+    secret: z.string().min(1),
+});
+/**
+ * What `endpoints.revealSigningSecret` answers (FXO-2244).
+ *
+ * The same value `endpoints.create` and `endpoints.rotateSigningKey` hand out
+ * once, readable again by a signed-in member. Mirrors `signingKeys`: during a
+ * rotation both keys are here, with the instant the overlap ends, because a
+ * receiver being moved to the new key needs both until then.
+ */
+export const callbackEndpointSigningSecretsSchema = z.object({
+    current: callbackEndpointSigningSecretSchema,
+    /** The endpoint these belong to, so an answer names what it is about. */
+    id: endpointIdSchema,
+    next: callbackEndpointSigningSecretSchema
+        .extend({ overlapEndsAt: timestampSchema })
+        .optional(),
+});
 function callbackUrlSchema() {
     return z
         .string()
@@ -113,67 +164,12 @@ function callbackUrlSchema() {
     });
 }
 export const callbackEndpointRequestSchema = z.object({
+    /**
+     * A name for people (W4-14, FXO-2255). Omitted on a create, the endpoint
+     * takes its whole URL as its name; omitted on an update, the stored name
+     * stays. Unique within the project and environment, compared exactly: a
+     * name another endpoint holds is refused as `state_conflict`.
+     */
+    name: callbackEndpointNameSchema.optional(),
     url: callbackUrlSchema(),
 });
-export const CALLBACK_VERIFICATION_PROTOCOL_VERSION = "2026-08-05";
-export const CALLBACK_VERIFICATION_TYPE = "callback.endpoint.verification";
-/**
- * Exact verification bytes sent to the receiver. The receiver validates the
- * request signature and proves possession of the one-time secret by returning
- * an HMAC of `challenge` in `Callback-Verification-Response`.
- */
-export const callbackVerificationChallengeSchema = z.object({
-    challenge: z.string().regex(/^cvc_[A-Za-z0-9_-]{43}$/u),
-    endpointId: endpointIdSchema,
-    type: z.literal(CALLBACK_VERIFICATION_TYPE),
-    version: z.literal(CALLBACK_VERIFICATION_PROTOCOL_VERSION),
-});
-export const CALLBACK_VERIFICATION_HEADERS = {
-    challenge: "Callback-Verification-Challenge",
-    requestSignature: "Callback-Verification-Signature",
-    responseSignature: "Callback-Verification-Response",
-};
-/**
- * Machine-readable receiver contract for endpoint ownership verification.
- *
- * This is deliberately separate from W3-02's occurrence-delivery signature:
- * the request proves control of a receiver before the endpoint may be used,
- * while a delivery signature authenticates an occurrence body later. The
- * generator publishes this object beside OpenAPI and the JSON Schema.
- */
-export const CALLBACK_VERIFICATION_PROTOCOL = {
-    purpose: "Prove that the receiver possesses the one-time endpoint secret before Greatwait marks the endpoint verified.",
-    request: {
-        bodyEncoding: "UTF-8 bytes of the compact JSON object in schema property order: challenge, endpointId, type, version.",
-        contentType: "application/json",
-        method: "POST",
-        redirectPolicy: "manual; every 3xx response is refused",
-        signature: {
-            algorithm: "HMAC-SHA-256",
-            format: "v1=<64 lowercase hexadecimal characters>",
-            header: CALLBACK_VERIFICATION_HEADERS.requestSignature,
-            input: "the exact request body bytes",
-            key: "the one-time endpoint secret returned by REST endpoint creation",
-        },
-    },
-    response: {
-        body: "ignored after enforcing the 1024-byte response limit; return an empty body",
-        proof: {
-            algorithm: "HMAC-SHA-256",
-            format: "v1=<64 lowercase hexadecimal characters>",
-            header: CALLBACK_VERIFICATION_HEADERS.responseSignature,
-            input: "the UTF-8 bytes of the challenge string",
-            key: "the same endpoint secret",
-        },
-        status: "any 2xx status",
-    },
-    testVector: {
-        challenge: "cvc_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
-        endpointId: "ep_00000000000000000000000000",
-        exactBodyBase64: "eyJjaGFsbGVuZ2UiOiJjdmNfQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQSIsImVuZHBvaW50SWQiOiJlcF8wMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCIsInR5cGUiOiJjYWxsYmFjay5lbmRwb2ludC52ZXJpZmljYXRpb24iLCJ2ZXJzaW9uIjoiMjAyNi0wOC0wNSJ9",
-        requestSignature: "v1=0d24c7fed4d752411b88025a9923627b329e0eb9d53978a6ebcf92c0678c731e",
-        responseSignature: "v1=efc690a23f1870930ff3388313162c0e06406902a7a4d3f9273ffe0abcef86bd",
-        secret: "verification-vector-secret",
-    },
-    version: CALLBACK_VERIFICATION_PROTOCOL_VERSION,
-};

package/dist/events.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "./zod.js";
 /**
  * Product events.
  *
@@ -11,7 +11,7 @@ import { z } from "zod";
  * collapsing them is how "why is this event from the future" bugs start.
  */
 export declare const EVENT_TYPES: readonly ["endpoint.verified", "occurrence.attempt.recorded", "occurrence.due", "occurrence.succeeded", "occurrence.terminal_failed", "schedule.cancelled", "schedule.completed", "schedule.created", "schedule.replaced"];
-export declare const eventTypeSchema: z.ZodEnum<{
+export declare const eventTypeSchema: import("zod").ZodEnum<{
     "endpoint.verified": "endpoint.verified";
     "occurrence.attempt.recorded": "occurrence.attempt.recorded";
     "occurrence.due": "occurrence.due";
@@ -23,13 +23,13 @@ export declare const eventTypeSchema: z.ZodEnum<{
     "schedule.replaced": "schedule.replaced";
 }>;
 export type EventType = z.infer<typeof eventTypeSchema>;
-export declare function eventEnvelopeSchema<TData extends z.ZodTypeAny>(data: TData): z.ZodObject<{
+export declare function eventEnvelopeSchema<TData extends z.ZodTypeAny>(data: TData): import("zod").ZodObject<{
     data: TData;
-    id: z.ZodString;
-    occurredAt: z.ZodString;
-    recordedAt: z.ZodString;
-    schemaVersion: z.ZodNumber;
-    type: z.ZodEnum<{
+    id: import("zod").ZodString;
+    occurredAt: import("zod").ZodString;
+    recordedAt: import("zod").ZodString;
+    schemaVersion: import("zod").ZodNumber;
+    type: import("zod").ZodEnum<{
         "endpoint.verified": "endpoint.verified";
         "occurrence.attempt.recorded": "occurrence.attempt.recorded";
         "occurrence.due": "occurrence.due";
@@ -40,14 +40,14 @@ export declare function eventEnvelopeSchema<TData extends z.ZodTypeAny>(data: TD
         "schedule.created": "schedule.created";
         "schedule.replaced": "schedule.replaced";
     }>;
-}, z.core.$strip>;
-export declare const genericEventSchema: z.ZodObject<{
-    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    id: z.ZodString;
-    occurredAt: z.ZodString;
-    recordedAt: z.ZodString;
-    schemaVersion: z.ZodNumber;
-    type: z.ZodEnum<{
+}, import("zod/v4/core").$strip>;
+export declare const genericEventSchema: import("zod").ZodObject<{
+    data: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    id: import("zod").ZodString;
+    occurredAt: import("zod").ZodString;
+    recordedAt: import("zod").ZodString;
+    schemaVersion: import("zod").ZodNumber;
+    type: import("zod").ZodEnum<{
         "endpoint.verified": "endpoint.verified";
         "occurrence.attempt.recorded": "occurrence.attempt.recorded";
         "occurrence.due": "occurrence.due";
@@ -58,5 +58,5 @@ export declare const genericEventSchema: z.ZodObject<{
         "schedule.created": "schedule.created";
         "schedule.replaced": "schedule.replaced";
     }>;
-}, z.core.$strip>;
+}, import("zod/v4/core").$strip>;
 export type GenericEvent = z.infer<typeof genericEventSchema>;

package/dist/events.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "./zod.js";
 import { eventIdSchema } from "./identifiers.js";
 import { timestampSchema } from "./time.js";
 /**

package/dist/first-value-journey.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "./zod.js";
 import type { ProblemCode } from "./problems.js";
 /**
  * The one bounded sequence that takes a developer from a credential to an
@@ -195,47 +195,47 @@ export interface JourneyStep {
  * carrying a real one would be a leak that no reviewer reads carefully enough
  * to catch, so the refusal is here rather than in a convention.
  */
-export declare const journeyVariableSchema: z.ZodObject<{
-    defaultExpression: z.ZodOptional<z.ZodObject<{
-        javascript: z.ZodString;
-        shell: z.ZodString;
-    }, z.core.$strip>>;
-    detail: z.ZodString;
-    name: z.ZodString;
-    placeholder: z.ZodString;
-    secret: z.ZodBoolean;
-    title: z.ZodString;
-}, z.core.$strip>;
-export declare const journeyStepSchema: z.ZodObject<{
-    capture: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        from: z.ZodString;
-        header: z.ZodOptional<z.ZodBoolean>;
-        secret: z.ZodOptional<z.ZodBoolean>;
-        variable: z.ZodString;
-    }, z.core.$strip>>>;
-    expect: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        equals: z.ZodString;
-        message: z.ZodString;
-        subject: z.ZodString;
-    }, z.core.$strip>>>;
-    key: z.ZodString;
-    observe: z.ZodString;
-    operationId: z.ZodString;
-    poll: z.ZodOptional<z.ZodObject<{
-        describe: z.ZodString;
-        intervalSeconds: z.ZodNumber;
-        timeoutSeconds: z.ZodNumber;
-    }, z.core.$strip>>;
-    purpose: z.ZodString;
-    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    recovery: z.ZodArray<z.ZodObject<{
-        nextMove: z.ZodString;
-        when: z.ZodString;
-    }, z.core.$strip>>;
-    request: z.ZodOptional<z.ZodUnknown>;
-    requestHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    title: z.ZodString;
-}, z.core.$strip>;
+export declare const journeyVariableSchema: import("zod").ZodObject<{
+    defaultExpression: import("zod").ZodOptional<import("zod").ZodObject<{
+        javascript: import("zod").ZodString;
+        shell: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    detail: import("zod").ZodString;
+    name: import("zod").ZodString;
+    placeholder: import("zod").ZodString;
+    secret: import("zod").ZodBoolean;
+    title: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
+export declare const journeyStepSchema: import("zod").ZodObject<{
+    capture: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        from: import("zod").ZodString;
+        header: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        secret: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        variable: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+    expect: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        equals: import("zod").ZodString;
+        message: import("zod").ZodString;
+        subject: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+    key: import("zod").ZodString;
+    observe: import("zod").ZodString;
+    operationId: import("zod").ZodString;
+    poll: import("zod").ZodOptional<import("zod").ZodObject<{
+        describe: import("zod").ZodString;
+        intervalSeconds: import("zod").ZodNumber;
+        timeoutSeconds: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+    purpose: import("zod").ZodString;
+    query: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    recovery: import("zod").ZodArray<import("zod").ZodObject<{
+        nextMove: import("zod").ZodString;
+        when: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    request: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    requestHeaders: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    title: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
 /**
  * The lowest curl that runs the generated commands.
  *
@@ -303,3 +303,153 @@ export declare function resolveJourneyReferences<T>(value: T, resolve: (name: st
  * value the reader supplies from one an earlier call handed them.
  */
 export declare function journeyCapturedVariables(): readonly string[];
+/**
+ * The website's rendering of the same journey.
+ *
+ * **Declared here rather than in the dashboard, because it is the *binding*
+ * between two things that already exist and neither of them may own it.** The
+ * dashboard has a four-step onboarding flow derived from what a member's
+ * project contains; this file has a nine-step sequence derived from the
+ * operation registry. Left unrelated they answered the same question with
+ * different words and different examples, and the website's answer was the one
+ * that went stale: its "Schedule a one-shot" step rendered the registry's
+ * `schedules.create` example, which is a **recurring cron** — a live dashboard
+ * action showing a reader the one thing the step promises it is not.
+ *
+ * So a website step names journey steps, and never a body, a title or a
+ * sentence of its own. What the browser prints is what the curl page prints,
+ * because it is the same declaration rendered twice.
+ *
+ */
+export declare const WEBSITE_JOURNEY_STEP_KEYS: Readonly<Record<string, readonly string[]>>;
+/** The journey steps a website step renders, resolved against the sequence. */
+export declare function websiteJourneySteps(step: string): readonly JourneyStep[];
+/**
+ * The bounded wait the website inherits, rather than one it chose.
+ *
+ * W9-01's fourth criterion asks the browser to bound outcome polling and to
+ * leave a recovery action on timeout. The journey already declares both numbers
+ * on `await-occurrence`, and the curl and JavaScript quickstarts already wait
+ * exactly that long — so a browser that picked its own interval would be a
+ * third answer to a question with one published answer, and the reader who
+ * followed both would be told two different things about how long to wait.
+ */
+export declare function journeyPoll(key: string): JourneyPoll;
+/**
+ * What the reader has to bring, in the words the quickstarts already use.
+ *
+ * The website used to write its own: "anything that can take an HTTP POST. A
+ * webhook playground is fine for a first look." That sentence steered a new
+ * customer to paste their first callback into a third-party inspection service,
+ * which is the thing this project's receiver decision exists to refuse, and it
+ * disagreed with the curl page on the same screenful of product.
+ *
+ * The operator's decision on W9-01 was that the *invitation* says none of this
+ * — a prerequisite stated before somebody has any context is noise they cannot
+ * act on. It is said here instead, at the step that needs it.
+ */
+export declare function journeyPrerequisite(id: string): JourneyPrerequisite;
+/**
+ * How long a website step took, as a bucket and never as a number.
+ *
+ * Coarser than `MCP_ACTIVATION_DURATIONS`, because these measure different
+ * things: a connection test is a handshake and finishes in seconds, and a
+ * person adding a destination and scheduling a callback is doing minutes of
+ * work. Reusing the millisecond buckets would put every website step in
+ * `over_30s` and record nothing.
+ */
+export declare const JOURNEY_ACTIVATION_DURATIONS: readonly ["under_1m", "under_5m", "under_15m", "over_15m"];
+export type JourneyActivationDuration = (typeof JOURNEY_ACTIVATION_DURATIONS)[number];
+export declare function journeyActivationDuration(elapsedMs: number): JourneyActivationDuration;
+/** Every way a website step can end, drawn from a closed list. */
+export declare const JOURNEY_ACTIVATION_OUTCOMES: readonly ["reached", "refused", "timed_out", "failed"];
+export type JourneyActivationOutcome = (typeof JOURNEY_ACTIVATION_OUTCOMES)[number];
+/** The website steps an activation fact may name. */
+export declare const WEBSITE_JOURNEY_STEPS: readonly ["destination", "scheduled", "delivered"];
+/**
+ * What is recorded when somebody moves through the website journey, and the
+ * only thing that is.
+ *
+ * **Modelled on `mcpActivationEventSchema` down to the `strictObject`, and for
+ * the same reason.** Every field is drawn from a closed set: there is no
+ * free-text field, no identifier, no address, no URL and no measurement finer
+ * than a bucket, so an event of this shape cannot carry an account, an
+ * organization, a project, an invitation link, a token, a destination or a
+ * payload however carelessly it is constructed.
+ *
+ * Strict rather than merely typed. An ordinary object schema *strips* what it
+ * does not know, so an emitter that added `project` would look like it was
+ * recording one while the field silently vanished — safe and dishonest at once.
+ * The MCP schema learned that from a test and this one inherits the lesson
+ * rather than rediscovering it.
+ */
+export declare const websiteActivationEventSchema: import("zod").ZodObject<{
+    duration: import("zod").ZodEnum<{
+        under_1m: "under_1m";
+        under_5m: "under_5m";
+        under_15m: "under_15m";
+        over_15m: "over_15m";
+    }>;
+    outcome: import("zod").ZodEnum<{
+        failed: "failed";
+        timed_out: "timed_out";
+        refused: "refused";
+        reached: "reached";
+    }>;
+    step: import("zod").ZodEnum<{
+        delivered: "delivered";
+        destination: "destination";
+        scheduled: "scheduled";
+    }>;
+    type: import("zod").ZodLiteral<"website.journey_step">;
+}, import("zod/v4/core").$strict>;
+export type WebsiteActivationEvent = z.infer<typeof websiteActivationEventSchema>;
+/**
+ * Parses an activation fact before it leaves the browser.
+ *
+ * The parse is the control, exactly as it is on the MCP side: a caller hands
+ * this an object and the schema refuses anything the closed sets do not admit,
+ * so the mistake surfaces where it was made rather than as a field that quietly
+ * disappeared.
+ */
+export declare function parseWebsiteActivationEvent(value: unknown): WebsiteActivationEvent;
+/**
+ * A path parameter's name, as the journey's variables spell it.
+ *
+ * **Published because a machine consumer cannot run the journey without it.**
+ * A step names its operation and the variables it needs — `read-schedule` says
+ * `/v1/schedules/{scheduleId}` and, separately, `GREATWAIT_SCHEDULEID` — and
+ * the rule joining the two lived in `scripts/first-value-projection.ts`, which
+ * is not published. A documentation page never notices: it renders both halves
+ * as text and a human joins them by eye. A command-line client has to *fill*
+ * the parameter, and had to re-derive the convention by guessing at it.
+ *
+ * The transformation is deliberately total and lossy in the safe direction:
+ * every non-alphanumeric character becomes `_`, so a parameter that differs
+ * from another only in punctuation would collide. `journeyPathVariables` is
+ * where that would surface, and `first-value-journey.test.ts` holds the
+ * journey's own parameters to distinct names.
+ */
+export declare function journeyVariableName(parameter: string): string;
+/** Every `{parameter}` in a path, in the order the path names them. */
+export declare function pathParameterNames(path: string): readonly string[];
+/**
+ * The variables a step's path parameters are filled from, in path order.
+ *
+ * Order is the contract: a client filling positional arguments — which is what
+ * the generated client takes — needs them in the order the path names them,
+ * and `attempts.list` has two.
+ */
+export declare function journeyPathVariables(step: JourneyStep): readonly string[];
+/**
+ * Everything a step must be given before it can be performed.
+ *
+ * **Published because it is a join, and a join is where a second consumer
+ * invents its own copy.** A step's inputs come from three places — the
+ * operation's path parameters, the `{{…}}` references in its body, query and
+ * headers — and stitching them is the kind of two-line rule every consumer gets
+ * *nearly* right. The machine-readable artifact's own `variables` field is this
+ * function, so a client reading the artifact and a client reading this module
+ * cannot disagree about what a step needs.
+ */
+export declare function journeyStepVariables(step: JourneyStep): readonly string[];