palbase 0.14.0 → 0.14.2

package/types/internal/src/modules/journeys.d.ts

@@ -0,0 +1,1223 @@
+import { type Reply, type Transport } from '../transport.js';
+/**
+ * Holds when the person is (in, the default) or is not in an audience.
+ */
+export type AudienceCondition = {
+    /**
+     * The audience's id
+     */
+    id: string;
+    /**
+     * false: holds when they are not in it
+     */
+    in?: boolean;
+};
+/**
+ * Sends the person on to then when if holds of them, else to else.
+ */
+export type BranchStep = {
+    /**
+     * The step when it does not: a step's id, or end
+     */
+    else: string;
+    if: Condition;
+    /**
+     * The step when it holds: a step's id, or end
+     */
+    then: string;
+};
+/**
+ * What a branch asks of a person, one of: a property of theirs; whether they are in an audience; whether they did an event (since they entered, or within a while); all, any or none of others.
+ */
+export type Condition = {
+    /**
+     * Holds when every one holds
+     */
+    all?: Condition[];
+    /**
+     * Holds when one holds
+     */
+    any?: Condition[];
+    audience?: AudienceCondition;
+    event?: EventCondition;
+    not?: Condition;
+    property?: PropertyCondition;
+};
+/**
+ * A journey's copy: its key, and a new name if it has one.
+ */
+export type CopyWrite = {
+    /**
+     * The copy's key
+     */
+    key: string;
+    /**
+     * The copy's name; the journey's unless it says
+     */
+    name?: string;
+};
+/**
+ * Gives the person their code of one of the project's coupons: {{coupon}} in the messages after it.
+ */
+export type CouponStep = {
+    /**
+     * The coupon's key
+     */
+    key: string;
+};
+/**
+ * A journey: who enters (entry), the steps each person who entered goes through from start, what the journey is for (goal) and what takes a person out (exit). Steps are keyed by id; each does one thing and names the step after it (next; none, or end, ends the person's run). A person is in a journey once at a time.
+ */
+export type Definition = {
+    entry: Entry;
+    exit?: Exit;
+    goal?: Goal;
+    /**
+     * The journey's name, 1 to 200 bytes
+     */
+    name: string;
+    reentry?: Reentry;
+    /**
+     * The first step's id
+     */
+    start: string;
+    /**
+     * The steps by id (a-z, 0-9 and _, starting with a letter; end is taken): 100 at most, every one reachable from start, no way back to a step already taken but through a wait.
+     */
+    steps: {
+        [key: string]: Step;
+    };
+};
+/**
+ * A definition: a draft's new one, or one to check.
+ */
+export type DefinitionWrite = {
+    definition: Definition;
+};
+/**
+ * An email from one of the project's email templates.
+ */
+export type EmailStep = {
+    /**
+     * The message category
+     */
+    category?: string;
+    /**
+     * The template's key
+     */
+    template: string;
+    /**
+     * The template's variables; {{coupon}} is the code a coupon step gave
+     */
+    variables?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Who enters, one of: a person who does an event; who comes to be in an audience; who has not done an event for a while; an audience's members when the journey is published.
+ */
+export type Entry = {
+    /**
+     * An audience's id: who comes to be in it enters
+     */
+    audience?: string;
+    event?: EventMatch;
+    inactive?: Inactive;
+    /**
+     * An audience's id: its members enter when the journey is published
+     */
+    members_of?: string;
+};
+/**
+ * A journey's way in.
+ */
+export type EntryInfo = {
+    /**
+     * The event's name, or the audience's id
+     */
+    key: string;
+    /**
+     * event, audience, inactive or members_of
+     */
+    kind: "event" | "audience" | "inactive" | "members_of";
+};
+/**
+ * The error envelope every error answers.
+ */
+export type ErrorResponse = {
+    /**
+     * Machine-readable error code (snake_case)
+     */
+    error: string;
+    /**
+     * Human-readable explanation
+     */
+    error_description: string;
+    /**
+     * Correlation ID
+     */
+    request_id: string;
+    /**
+     * Seconds to wait before retrying, when the refusal ends with time.
+     */
+    retry_after?: number;
+    /**
+     * HTTP status code
+     */
+    status: number;
+};
+/**
+ * Holds when the person did the event since they entered the journey, or within a while.
+ */
+export type EventCondition = {
+    /**
+     * The event's name
+     */
+    name: string;
+    /**
+     * Properties the event must have, each equal
+     */
+    where?: {
+        [key: string]: unknown;
+    };
+    /**
+     * How long back, an ISO 8601 duration: PT30M, PT2H, P2D, P1W; since entering unless it says
+     */
+    within?: string;
+};
+/**
+ * An event by its name (an app's event, or a module's: purchases.purchase.completed, purchases.coupon.redeemed, audience.entered), with properties it must have, each equal.
+ */
+export type EventMatch = {
+    /**
+     * The event's name
+     */
+    name: string;
+    /**
+     * Properties the event must have, each equal to its value
+     */
+    where?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * Tells the project's backend: a journey.event (a webhook, or an @On) with the name and data.
+ */
+export type EventStep = {
+    /**
+     * Data it carries
+     */
+    data?: {
+        [key: string]: unknown;
+    };
+    /**
+     * The event's own name
+     */
+    name: string;
+};
+/**
+ * What takes a person out before the end.
+ */
+export type Exit = {
+    /**
+     * An audience's id: leaving it takes them out
+     */
+    audience_left?: string;
+    /**
+     * Events that take them out
+     */
+    events?: EventMatch[];
+};
+/**
+ * What the journey is for: an event of the person's within a while of entering. A run that sees it ends converted; one that completed before it is counted converted too.
+ */
+export type Goal = {
+    event: EventMatch;
+    /**
+     * How long after entering it counts, an ISO 8601 duration: PT30M, PT2H, P2D, P1W; 30 days unless it says, 90 days at most
+     */
+    within?: string;
+};
+/**
+ * One of the project's in-app campaigns made for journeys, shown to the person the next time it is triggered in their app.
+ */
+export type InAppStep = {
+    /**
+     * The campaign's id: an in-app campaign made for journeys (for_journeys)
+     */
+    campaign: string;
+    /**
+     * For how many days it waits to be shown; 7 unless it says
+     */
+    days?: number;
+};
+/**
+ * The runs open now.
+ */
+export type InProgress = {
+    /**
+     * Taking a step
+     */
+    active: number;
+    /**
+     * Waiting to enter until the project has monthly people again
+     */
+    held: number;
+    /**
+     * At a wait
+     */
+    waiting: number;
+};
+/**
+ * Enters a person who has not done an event for a while: the moment the while passes since their last one.
+ */
+export type Inactive = {
+    /**
+     * The event's name ($session_start: who has not opened the app)
+     */
+    event: string;
+    /**
+     * How long, an ISO 8601 duration: PT30M, PT2H, P2D, P1W; 1 hour to 90 days
+     */
+    for: string;
+};
+/**
+ * A message to the person's inbox.
+ */
+export type InboxStep = {
+    /**
+     * The body by locale; 2,000 bytes each
+     */
+    body: {
+        [key: string]: string;
+    };
+    /**
+     * The message category
+     */
+    category?: string;
+    /**
+     * Data the app receives with it
+     */
+    data?: {
+        [key: string]: string;
+    };
+    /**
+     * Where opening it goes
+     */
+    deep_link?: string;
+    /**
+     * Days it stays in the inbox
+     */
+    expires_in_days?: number;
+    /**
+     * An image's https URL
+     */
+    image?: string;
+    /**
+     * The title by locale; 200 bytes each
+     */
+    title: {
+        [key: string]: string;
+    };
+    /**
+     * Variables the words use
+     */
+    variables?: {
+        [key: string]: string;
+    };
+};
+/**
+ * A definition that breaks a rule: the error envelope (invalid_journey, the first problem in error_description) and every problem, each at its path with what to do about it.
+ */
+export type InvalidJourney = {
+    /**
+     * invalid_journey
+     */
+    error: string;
+    /**
+     * The first problem: its path and what is wrong
+     */
+    error_description: string;
+    /**
+     * Every problem found
+     */
+    problems: Problem[];
+    /**
+     * Correlation ID
+     */
+    request_id: string;
+    /**
+     * 422
+     */
+    status: number;
+};
+/**
+ * A journey whole.
+ */
+export type Journey = {
+    /**
+     * When it was made
+     */
+    created_at: string;
+    definition: Definition;
+    entry: EntryInfo;
+    /**
+     * The journey's key
+     */
+    key: string;
+    /**
+     * Its name
+     */
+    name: string;
+    /**
+     * When it was published
+     */
+    published_at: string | null;
+    /**
+     * draft, live or stopped
+     */
+    status: "draft" | "live" | "stopped";
+    /**
+     * When it was stopped
+     */
+    stopped_at: string | null;
+    /**
+     * When it last changed
+     */
+    updated_at: string;
+};
+/**
+ * journey.converted: a person's run reached the journey's goal.
+ */
+export type JourneyConvertedEvent = {
+    /**
+     * The journey's key
+     */
+    journey: string;
+    /**
+     * The journey's id
+     */
+    journey_id: string;
+    /**
+     * The run's id
+     */
+    run_id: string;
+    /**
+     * The person
+     */
+    user_id: string;
+};
+/**
+ * journey.ended: a person's run ended.
+ */
+export type JourneyEndedEvent = {
+    /**
+     * The journey's key
+     */
+    journey: string;
+    /**
+     * The journey's id
+     */
+    journey_id: string;
+    /**
+     * completed, converted, exited, stopped, or failed (a step failed every try)
+     */
+    reason: "completed" | "converted" | "exited" | "stopped" | "failed";
+    /**
+     * The run's id
+     */
+    run_id: string;
+    /**
+     * The person
+     */
+    user_id: string;
+};
+/**
+ * journey.entered: a person entered a journey.
+ */
+export type JourneyEnteredEvent = {
+    /**
+     * The journey's key
+     */
+    journey: string;
+    /**
+     * The journey's id
+     */
+    journey_id: string;
+    /**
+     * The run's id
+     */
+    run_id: string;
+    /**
+     * The person
+     */
+    user_id: string;
+};
+/**
+ * journey.event: a journey's event step told the project's backend.
+ */
+export type JourneyEventEvent = {
+    /**
+     * The data it carries
+     */
+    data?: {
+        [key: string]: unknown;
+    };
+    /**
+     * The journey's key
+     */
+    journey: string;
+    /**
+     * The journey's id
+     */
+    journey_id: string;
+    /**
+     * The step's event name
+     */
+    name: string;
+    /**
+     * The run's id
+     */
+    run_id: string;
+    /**
+     * The step's id
+     */
+    step: string;
+    /**
+     * The person
+     */
+    user_id: string;
+};
+/**
+ * A journey as a list shows it.
+ */
+export type JourneyInfo = {
+    /**
+     * When it was made
+     */
+    created_at: string;
+    entry: EntryInfo;
+    /**
+     * The journey's key
+     */
+    key: string;
+    /**
+     * Its name
+     */
+    name: string;
+    /**
+     * When it was published
+     */
+    published_at: string | null;
+    /**
+     * draft (changes), live (people enter it; it does not change), stopped (no one is in it; its report stays)
+     */
+    status: "draft" | "live" | "stopped";
+    /**
+     * When it was stopped
+     */
+    stopped_at: string | null;
+    /**
+     * When it last changed
+     */
+    updated_at: string;
+};
+/**
+ * The project's journeys, newest first.
+ */
+export type JourneyList = {
+    /**
+     * A page of them
+     */
+    journeys: JourneyInfo[];
+    /**
+     * The next page's cursor; absent on the last page
+     */
+    next_cursor?: string;
+};
+/**
+ * What came of a journey: who entered, how their runs ended, who is in it now, the goal's conversions, each step's outcomes, and each split's ways with their conversions.
+ */
+export type JourneyStats = {
+    /**
+     * Runs that reached the goal
+     */
+    converted: number;
+    /**
+     * Runs ended, by reason: completed, converted, exited, stopped, failed (a step failed every try), erased (the person was deleted)
+     */
+    ended: {
+        [key: string]: number;
+    };
+    /**
+     * People who entered
+     */
+    entered: number;
+    /**
+     * Entries held while the project's monthly people were used up
+     */
+    held: number;
+    in_progress: InProgress;
+    /**
+     * The journey's key
+     */
+    key: string;
+    /**
+     * draft, live or stopped
+     */
+    status: "draft" | "live" | "stopped";
+    /**
+     * Each step from the start, in order
+     */
+    steps: StepStats[];
+};
+/**
+ * journey.step: a person's run took a step.
+ */
+export type JourneyStepEvent = {
+    /**
+     * The journey's key
+     */
+    journey: string;
+    /**
+     * The journey's id
+     */
+    journey_id: string;
+    /**
+     * What it does
+     */
+    kind: string;
+    /**
+     * What it came to
+     */
+    outcome: string;
+    /**
+     * The run's id
+     */
+    run_id: string;
+    /**
+     * The step's id
+     */
+    step: string;
+    /**
+     * The person
+     */
+    user_id: string;
+};
+/**
+ * A new journey: its key and its definition.
+ */
+export type JourneyWrite = {
+    definition: Definition;
+    /**
+     * The journey's own name: 1 to 64 of a-z, 0-9 and _, starting with a letter (winback)
+     */
+    key: string;
+};
+/**
+ * Gives the person one of the catalog's grant offers: an entitlement for a while.
+ */
+export type OfferStep = {
+    /**
+     * The offer's key
+     */
+    key: string;
+};
+/**
+ * One thing wrong with a definition.
+ */
+export type Problem = {
+    /**
+     * What to do about it, when there is a known way
+     */
+    fix?: string;
+    /**
+     * What is wrong
+     */
+    message: string;
+    /**
+     * Where, as a dotted path into the definition: steps.mail.email.template, entry, goal.within
+     */
+    path: string;
+};
+/**
+ * Compares a person's property (analytics' people) with a value.
+ */
+export type PropertyCondition = {
+    /**
+     * The property's name
+     */
+    name: string;
+    /**
+     * eq, ne, gt, gte, lt, lte, contains (a string's), exists, missing
+     */
+    op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "contains" | "exists" | "missing";
+    /**
+     * The value compared with; none for exists and missing
+     */
+    value?: unknown;
+};
+/**
+ * A push notification to the person's devices: words by locale, or one of the project's push templates. {{coupon}} is the code a coupon step gave.
+ */
+export type PushStep = {
+    /**
+     * The body by locale; 2,000 bytes each
+     */
+    body?: {
+        [key: string]: string;
+    };
+    /**
+     * The message category the person's consent and the send rules read
+     */
+    category?: string;
+    /**
+     * Data the app receives with it
+     */
+    data?: {
+        [key: string]: string;
+    };
+    /**
+     * Where tapping it opens
+     */
+    deep_link?: string;
+    /**
+     * An image's https URL
+     */
+    image?: string;
+    /**
+     * Keeps a copy in the person's inbox too
+     */
+    inbox?: boolean;
+    /**
+     * One of the project's push templates, in place of title and body
+     */
+    template?: string;
+    /**
+     * The title by locale (BCP 47): en, tr, pt-BR; 200 bytes each
+     */
+    title?: {
+        [key: string]: string;
+    };
+    /**
+     * The template's variables
+     */
+    variables?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Whether a person who was in the journey enters it again.
+ */
+export type Reentry = {
+    /**
+     * With after: how long, an ISO 8601 duration: PT30M, PT2H, P2D, P1W; 1 hour to 365 days
+     */
+    after?: string;
+    /**
+     * once (never again, the default), always (each time, once their run ended), after (once after has passed since they last entered). Whatever it says, a person enters one journey 20 times a day at most: a journey whose own steps cause its entry event does not loop.
+     */
+    mode: "once" | "always" | "after";
+};
+/**
+ * A person's run through a journey: where it is, how it ended, and each step it took.
+ */
+export type Run = {
+    /**
+     * When it reached the goal
+     */
+    converted_at: string | null;
+    /**
+     * completed, converted, exited, stopped, or failed (a step failed every try)
+     */
+    end_reason: string | null;
+    /**
+     * When it ended
+     */
+    ended_at: string | null;
+    /**
+     * When the person entered
+     */
+    entered_at: string;
+    /**
+     * The run's id
+     */
+    id: string;
+    /**
+     * The journey's key
+     */
+    journey: string;
+    /**
+     * held (waiting to enter), active, waiting, ended
+     */
+    state: "held" | "active" | "waiting" | "ended";
+    /**
+     * The step it is at
+     */
+    step: string | null;
+    /**
+     * The steps it took, in order
+     */
+    steps: RunStep[];
+    /**
+     * The person
+     */
+    user_id: string;
+    /**
+     * When its wait ends
+     */
+    wake_at: string | null;
+};
+/**
+ * Runs, newest first.
+ */
+export type RunList = {
+    /**
+     * The next page's cursor; absent on the last page
+     */
+    next_cursor?: string;
+    /**
+     * A page of them
+     */
+    runs: Run[];
+};
+/**
+ * A step a run took, and what came of it.
+ */
+export type RunStep = {
+    /**
+     * When
+     */
+    at: string;
+    /**
+     * What it did: a message's ids and, held through the person's quiet hours, when it goes (held_until); why one was skipped (reason: consent, frequency_cap, preferences, no_address, deleted, quota_exceeded); why an offer was not granted; the event that ended a wait
+     */
+    detail: {
+        [key: string]: unknown;
+    };
+    /**
+     * What it does
+     */
+    kind: string;
+    /**
+     * What it came to
+     */
+    outcome: string;
+    /**
+     * The step's id
+     */
+    step: string;
+};
+/**
+ * Writes properties of the person's (analytics' people).
+ */
+export type SetStep = {
+    /**
+     * The properties and their values
+     */
+    properties: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * How and when the run ends.
+ */
+export type SimulatedEnd = {
+    /**
+     * When
+     */
+    at: string;
+    /**
+     * completed, converted or exited
+     */
+    reason: "completed" | "converted" | "exited";
+};
+/**
+ * An event the person does.
+ */
+export type SimulatedEvent = {
+    /**
+     * How long after entering, an ISO 8601 duration: PT30M, PT2H, P2D, P1W (PT0M: at once)
+     */
+    after: string;
+    /**
+     * The event's name
+     */
+    name: string;
+    /**
+     * Its properties
+     */
+    properties?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * Who walks: their properties and audiences when they enter, where they are, and what they do after.
+ */
+export type SimulatedPerson = {
+    /**
+     * The audiences they are in
+     */
+    audiences?: string[];
+    /**
+     * What they do after entering, 100 at most
+     */
+    events?: SimulatedEvent[];
+    /**
+     * Their properties, which branches read
+     */
+    properties?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Their IANA time zone (Europe/Istanbul), which waits until a time of day read
+     */
+    timezone?: string;
+    /**
+     * Their id, which chooses their way at a split
+     */
+    user_id?: string;
+};
+/**
+ * A step taken.
+ */
+export type SimulatedStep = {
+    /**
+     * When
+     */
+    at: string;
+    /**
+     * What it does: push, inbox, email, in_app, coupon, offer, set, event, wait, branch, split
+     */
+    kind: string;
+    /**
+     * What it would have done: the push's title, the email's template
+     */
+    note: string;
+    /**
+     * What it came to: sent, given, set, told, waiting, waited, event, timeout, then, else, a split's way
+     */
+    outcome: string;
+    /**
+     * The step's id
+     */
+    step: string;
+};
+/**
+ * The person's way through: each step, when, what it came to and what it would have done; how the run ends and when; when the goal came after it completed, if it did.
+ */
+export type Simulation = {
+    /**
+     * When the goal came after the run completed
+     */
+    converted_at: string | null;
+    end: SimulatedEnd;
+    /**
+     * The steps taken, in order
+     */
+    steps: SimulatedStep[];
+};
+/**
+ * Walks a person through a journey — the project's (key) or one not saved yet (definition) — from start: nothing is sent, given or written.
+ */
+export type SimulationWrite = {
+    definition?: Definition;
+    /**
+     * The project's journey to walk; or definition
+     */
+    key?: string;
+    person: SimulatedPerson;
+    /**
+     * When the person enters; now unless it says
+     */
+    start?: string;
+};
+/**
+ * One of a split's ways.
+ */
+export type SplitArm = {
+    /**
+     * The way's name (a, b, control), reported in the stats
+     */
+    name: string;
+    /**
+     * Its next step: a step's id, or end
+     */
+    next: string;
+    /**
+     * How many in a hundred take it, 1 to 99
+     */
+    weight: number;
+};
+/**
+ * One step: exactly one of push, inbox, email, in_app, coupon, offer, set, event, wait, branch, split — and next, where the person goes after it (none, or end, ends their run). A message step (push, inbox, email, in_app) is sent by the project's send rules: quiet hours, frequency caps and the person's consent; a message they did not allow is skipped and the run goes on.
+ */
+export type Step = {
+    branch?: BranchStep;
+    coupon?: CouponStep;
+    email?: EmailStep;
+    event?: EventStep;
+    in_app?: InAppStep;
+    inbox?: InboxStep;
+    /**
+     * The next step: a step's id, or end
+     */
+    next?: string;
+    offer?: OfferStep;
+    push?: PushStep;
+    set?: SetStep;
+    /**
+     * A/B split: 2 to 5 ways whose weights add up to 100; each person takes one by chance, the same one on every try
+     */
+    split?: SplitArm[];
+    wait?: WaitStep;
+};
+/**
+ * A step's outcomes; a split's, each way's conversions too.
+ */
+export type StepStats = {
+    /**
+     * A split's: the runs that took each way and reached the goal
+     */
+    converted?: {
+        [key: string]: number;
+    };
+    /**
+     * What it does
+     */
+    kind: string;
+    /**
+     * How many times it came to each outcome: sent, skipped, failed (the module it called refused it for good), given, no_code, granted, not_granted, set, told, waited, event, timeout, then, else, a split's way
+     */
+    outcomes: {
+        [key: string]: number;
+    };
+    /**
+     * The step's id
+     */
+    step: string;
+};
+/**
+ * What a definition's check found.
+ */
+export type Validation = {
+    /**
+     * Every problem, each at its path with what to do about it
+     */
+    problems: Problem[];
+    /**
+     * True when nothing is wrong
+     */
+    valid: boolean;
+};
+/**
+ * A definition to check: any JSON object — what breaks the journey's shape (Definition) or its rules is a problem in the answer, not a refusal.
+ */
+export type ValidationWrite = {
+    /**
+     * The definition to check
+     */
+    definition: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * Holds the person, one of: for a while; until a time of day where they are; until an event of theirs, at most timeout (then timeout_next, or the end).
+ */
+export type WaitStep = {
+    event?: EventMatch;
+    /**
+     * How long, an ISO 8601 duration: PT30M, PT2H, P2D, P1W; 1 minute to 90 days
+     */
+    for?: string;
+    /**
+     * With event: how long at most, an ISO 8601 duration: PT30M, PT2H, P2D, P1W
+     */
+    timeout?: string;
+    /**
+     * With event: the step after the timeout: a step's id, or end
+     */
+    timeout_next?: string;
+    /**
+     * A time of day, HH:MM, in the person's $timezone (UTC when they have none)
+     */
+    until?: string;
+};
+/** The events this module sends the project's webhooks (x-palbase-events), by type: each one's payload, the event's data. */
+export interface Events {
+    /**
+     * journey.converted: a person's run reached the journey's goal.
+     */
+    "journey.converted": JourneyConvertedEvent;
+    /**
+     * journey.ended: a person's run ended (completed, converted, exited, stopped).
+     */
+    "journey.ended": JourneyEndedEvent;
+    /**
+     * journey.entered: a person entered a journey.
+     */
+    "journey.entered": JourneyEnteredEvent;
+    /**
+     * journey.event: a journey's event step told the project's backend.
+     */
+    "journey.event": JourneyEventEvent;
+    /**
+     * journey.step: a person's run took a step.
+     */
+    "journey.step": JourneyStepEvent;
+}
+/** Palbase Journeys */
+export declare function client(t: Transport): {
+    /**
+     * List journeys
+     *
+     * The project's journeys, newest first, a page at a time; status narrows them to drafts, live or stopped ones.
+     */
+    listJourneys(input?: {
+        query?: {
+            status?: "draft" | "live" | "stopped"; /** How many, 1 to 200; 50 unless it says */
+            limit?: number; /** A page's next_cursor, for the page after it */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, JourneyList>>;
+    /**
+     * Create a journey
+     *
+     * Makes a draft journey from its definition. A definition that breaks a rule is refused with every problem, each at its path and with what to do about it (422 invalid_journey); POST /journeys/validate checks one without saving it. Nothing runs until it is published. A project keeps 500 journeys (409 too_many_journeys).
+     */
+    createJourney(input: {
+        body: JourneyWrite; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Journey>>;
+    /**
+     * A person's runs
+     *
+     * A person's runs through every journey, newest first, a page at a time, each with the steps it took and what came of them: what support reads when someone asks what they were sent.
+     */
+    listPersonRuns(input: {
+        path: {
+            user_id: string;
+        };
+        query?: {
+            limit?: number; /** A page's next_cursor, for the page after it */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, RunList>>;
+    /**
+     * Walk a person through a journey
+     *
+     * Walks a made-up person through a journey — the project's by key, or a definition not saved yet — as the engine would: each step, when, what it came to and what it would have done, and how the run ends. Waits take their time on paper; nothing is sent, given or written.
+     */
+    simulateJourney(input: {
+        body: SimulationWrite; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Simulation>>;
+    /**
+     * Check a definition
+     *
+     * Checks a definition without saving it: every problem, each at its path with what to do about it. A valid one is the same journey POST /journeys makes.
+     */
+    validateJourney(input: {
+        body: ValidationWrite; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Validation>>;
+    /**
+     * Read a journey
+     *
+     * A journey whole, with its definition.
+     */
+    getJourney(input: {
+        path: {
+            key: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Journey>>;
+    /**
+     * Change a draft
+     *
+     * Replaces a draft's definition. A published journey does not change (409 journey_published): copy it into a new draft, publish that and stop this one.
+     */
+    updateJourney(input: {
+        path: {
+            key: string;
+        };
+        body: DefinitionWrite; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Journey>>;
+    /**
+     * Delete a journey
+     *
+     * Deletes a journey, its runs and its report; the people in a live one leave it at once, and nothing more is sent them.
+     */
+    deleteJourney(input: {
+        path: {
+            key: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Copy a journey
+     *
+     * Copies a journey's definition into a new draft: how a live journey is changed (copy, change the copy, publish it, stop the old one).
+     */
+    copyJourney(input: {
+        path: {
+            key: string;
+        };
+        body: CopyWrite; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Journey>>;
+    /**
+     * Publish a draft
+     *
+     * Makes a draft live: from now people enter it (a members_of journey enters the audience's members at once), and it no longer changes. The Free plan runs 2 journeys at once (402 live_journeys_limit). Each person who enters a journey in a month counts toward the project's monthly journey people; once the Free plan's are used up, new entries wait for the next month while the people in journeys go on. Any project runs 50 journeys at once (409 too_many_live_journeys).
+     */
+    publishJourney(input: {
+        path: {
+            key: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Journey>>;
+    /**
+     * A journey's runs
+     *
+     * The people's runs through a journey, newest first, a page at a time, each with the steps it took and what came of them; user_id and state narrow them.
+     */
+    listJourneyRuns(input: {
+        path: {
+            key: string;
+        };
+        query?: {
+            user_id?: string; /** held, active, waiting or ended */
+            state?: "held" | "active" | "waiting" | "ended"; /** How many, 1 to 200; 50 unless it says */
+            limit?: number; /** A page's next_cursor, for the page after it */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, RunList>>;
+    /**
+     * What came of a journey
+     *
+     * Who entered, how their runs ended, who is in it now, the goal's conversions, each step's outcomes and each split's ways with their conversions.
+     */
+    getJourneyStats(input: {
+        path: {
+            key: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, JourneyStats>>;
+    /**
+     * Stop a journey
+     *
+     * Stops a live journey for good: from now no one enters it and no run of it takes another step; the runs in it end stopped within moments (a page at a time), and its report stays.
+     */
+    stopJourney(input: {
+        path: {
+            key: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Journey>>;
+};
+export type Client = ReturnType<typeof client>;