palbase 0.1.0 → 0.2.0

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

@@ -1087,6 +1087,152 @@ export type ErrorResponse = {
      */
     status: number;
 };
+/**
+ * An experiment on a placement. Its variants never change while it runs, so no one's variant does.
+ */
+export type Experiment = {
+    /**
+     * When it ended.
+     */
+    ended_at?: string;
+    /**
+     * Who ended it.
+     */
+    ended_by?: string;
+    /**
+     * The experiment's id.
+     */
+    id: string;
+    /**
+     * Its name.
+     */
+    name: string;
+    /**
+     * The placement it runs on.
+     */
+    placement: string;
+    /**
+     * When it started.
+     */
+    started_at: string;
+    /**
+     * Who started it (the key).
+     */
+    started_by: string;
+    /**
+     * running; stopped (the placement shows the first variant's paywall); won (the winner's).
+     */
+    status: "running" | "stopped" | "won";
+    /**
+     * The variants, the first the one a stop keeps.
+     */
+    variants: ExperimentVariant[];
+    /**
+     * The variant declared the winner.
+     */
+    winner?: string;
+};
+/**
+ * An experiment to start.
+ */
+export type ExperimentRequest = {
+    /**
+     * Its name (1 to 100 characters).
+     */
+    name: string;
+    /**
+     * The placement it runs on (made when new).
+     */
+    placement: string;
+    /**
+     * 2 to 4 variants, each its own published paywall; the first is the one a stop keeps.
+     */
+    variants: ExperimentVariant[];
+};
+/**
+ * What each variant's audience did, and which leads.
+ */
+export type ExperimentResults = {
+    /**
+     * When the numbers were counted.
+     */
+    computed_at: string;
+    /**
+     * Whether the leader's chance to win is 95% or more and every variant was seen by 100 subjects or more: declaring it the winner is sound.
+     */
+    confident: boolean;
+    /**
+     * The experiment.
+     */
+    experiment_id: string;
+    /**
+     * The variant with the highest chance to win; absent before anyone saw one.
+     */
+    leader?: string;
+    /**
+     * Whether the stores' test purchases count.
+     */
+    sandbox: boolean;
+    /**
+     * The experiment's status.
+     */
+    status: "running" | "stopped" | "won";
+    /**
+     * Each variant, in the experiment's order.
+     */
+    variants: VariantResult[];
+    /**
+     * The days after first seeing a variant a purchase counts for it.
+     */
+    window_days: number;
+};
+/**
+ * A variant: a paywall shown to its share of the placement's audience — its weight over the variants' weights together.
+ */
+export type ExperimentVariant = {
+    /**
+     * The variant's key (a, b, control …): lowercase letters, digits and _, at most 20.
+     */
+    key: string;
+    /**
+     * The paywall it shows (published).
+     */
+    paywall_id: string;
+    /**
+     * Its weight.
+     */
+    weight: number;
+};
+/**
+ * A page of the project's experiments, newest first.
+ */
+export type Experiments = {
+    /**
+     * The experiments.
+     */
+    experiments: Experiment[];
+    /**
+     * The next page's cursor; absent on the last.
+     */
+    next_cursor?: string;
+};
+/**
+ * What an app showed at a placement, as it was given it.
+ */
+export type ExposureRequest = {
+    /**
+     * The paywall.
+     */
+    paywall_id: string;
+    /**
+     * The variant it was given, when an experiment runs on the placement.
+     */
+    variant?: string;
+    /**
+     * Its version.
+     */
+    version: number;
+};
 /**
  * A granted (promotional) entitlement.
  */
@@ -1364,90 +1510,776 @@ export type OfferingPlan = {
     /**
      * What the store sells it by: the App Store's product id, Google Play's product id, Stripe's price lookup key.
      */
-    store_id: string;
+    store_id: string;
+};
+/**
+ * The paywall's catalog: the products on sale.
+ */
+export type Offerings = {
+    /**
+     * The products, each on the channels it is sold on.
+     */
+    products: Offering[];
+    /**
+     * The catalog's revision.
+     */
+    revision: number;
+};
+/**
+ * What a quota spend took in credits past its limit.
+ */
+export type OverflowReceipt = {
+    /**
+     * What is available of it after.
+     */
+    available_after: number;
+    /**
+     * The credit's balance after.
+     */
+    balance_after: number;
+    /**
+     * Credits taken.
+     */
+    committed: number;
+    /**
+     * What it took, lot by lot.
+     */
+    consumed: CreditConsumption[];
+    /**
+     * The credit.
+     */
+    currency: string;
+    /**
+     * Credits held.
+     */
+    held: number;
+    /**
+     * What a unit cost.
+     */
+    per_unit: number;
+    /**
+     * Credits handed back.
+     */
+    reversed: number;
+    /**
+     * How many units went past the limit.
+     */
+    units: number;
+};
+/**
+ * purchases.ownership.transferred: a purchase moved from one customer to another: the second restored the App Store purchases of the Apple ID it was made with.
+ */
+export type OwnershipTransferredEvent = {
+    /**
+     * The purchase's id in the ledger.
+     */
+    chain_id: string;
+    /**
+     * Who had it.
+     */
+    from_customer_id: string;
+    /**
+     * The catalog's product; empty when unmapped.
+     */
+    product: string;
+    /**
+     * Where it was bought.
+     */
+    store: "app_store" | "play_store" | "stripe";
+    /**
+     * Who has it now.
+     */
+    to_customer_id: string;
+    /**
+     * How.
+     */
+    via: "restore";
+};
+/**
+ * A paywall as Studio edits it: its draft, and what was published of it.
+ */
+export type Paywall = {
+    /**
+     * When it was made.
+     */
+    created_at: string;
+    /**
+     * Who made it (the key).
+     */
+    created_by: string;
+    draft: PaywallDefinition;
+    /**
+     * Rises with every save of the draft; If-Match names it.
+     */
+    draft_revision: number;
+    /**
+     * The paywall's id.
+     */
+    id: string;
+    /**
+     * Its name (the draft's).
+     */
+    name: string;
+    /**
+     * What there is to say of the draft against the catalog as it is: warnings — a package the catalog does not sell yet is one here and stops a publish.
+     */
+    problems: PaywallProblem[];
+    /**
+     * When the newest version was published.
+     */
+    published_at?: string;
+    /**
+     * The newest version published; 0 before the first.
+     */
+    published_version: number;
+    /**
+     * When the draft was last saved.
+     */
+    updated_at: string;
+    /**
+     * Who saved it last.
+     */
+    updated_by: string;
+};
+/**
+ * The button that closes the paywall.
+ */
+export type PaywallCloseButton = {
+    /**
+     * Its color. A color of the theme (background, surface, text, muted, accent, on_accent, badge) — the light or the dark palette's, as the app appears —, or #RRGGBB / #RRGGBBAA in both.
+     */
+    color?: string;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * The component.
+     */
+    type: "close_button";
+};
+/**
+ * A component, by its type. A newer schema adds components; an app never draws a definition with one it does not know.
+ */
+export type PaywallComponent = PaywallStack | PaywallText | PaywallImage | PaywallIcon | PaywallFeatures | PaywallPackages | PaywallPurchaseButton | PaywallRestoreButton | PaywallLink | PaywallCloseButton | PaywallSpacer | PaywallDivider;
+/**
+ * A paywall: a tree of components an app draws natively (SwiftUI on iOS, the DOM on the web), its texts in each language and its two palettes. Prices are never in it: an app fills `{{price}}` and the other variables from its store. The server refuses what it does not know — a field, a component, a newer schema — and holds a definition to bounds: 64 KiB of JSON, 200 components, 12 deep, 500 characters a text, 40 languages.
+ */
+export type PaywallDefinition = {
+    /**
+     * The language a text falls back to: a tag such as en or pt-BR.
+     */
+    default_locale: string;
+    locales?: PaywallLocales;
+    /**
+     * The paywall's name, for the people who edit it (1 to 100 characters).
+     */
+    name: string;
+    root: PaywallComponent;
+    /**
+     * The schema the definition is written in. An app asks for the newest schema it draws (`X-Palbase-Paywall-Schema`) and is given the newest version written in it or an older one.
+     */
+    schema: number;
+    theme: PaywallTheme;
+};
+/**
+ * A thin line across its stack.
+ */
+export type PaywallDivider = {
+    /**
+     * Its color. A color of the theme (background, surface, text, muted, accent, on_accent, badge) — the light or the dark palette's, as the app appears —, or #RRGGBB / #RRGGBBAA in both.
+     */
+    color?: string;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * The component.
+     */
+    type: "divider";
+};
+/**
+ * The error envelope of a refused definition, with every problem when it breaks a rule (`invalid_paywall`).
+ */
+export type PaywallError = {
+    /**
+     * Machine-readable error code (snake_case)
+     */
+    error: string;
+    /**
+     * Human-readable explanation
+     */
+    error_description: string;
+    /**
+     * Every problem, by path: with `invalid_paywall`, absent otherwise.
+     */
+    problems?: PaywallProblem[];
+    /**
+     * Correlation ID for log/audit lookup
+     */
+    request_id: string;
+    /**
+     * Seconds to wait before retrying; present on a refusal that ends with time.
+     */
+    retry_after?: number;
+    /**
+     * HTTP status code (mirrors the response status)
+     */
+    status: number;
+};
+/**
+ * A feature.
+ */
+export type PaywallFeatureItem = {
+    icon: PaywallIconName;
+    text: PaywallString;
+};
+/**
+ * A list of what the purchase gives, each with an icon.
+ */
+export type PaywallFeatures = {
+    /**
+     * The texts' color. A color of the theme (background, surface, text, muted, accent, on_accent, badge) — the light or the dark palette's, as the app appears —, or #RRGGBB / #RRGGBBAA in both.
+     */
+    color?: string;
+    /**
+     * The icons' color. A color of the theme (background, surface, text, muted, accent, on_accent, badge) — the light or the dark palette's, as the app appears —, or #RRGGBB / #RRGGBBAA in both.
+     */
+    icon_color?: string;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * The features, 1 to 12.
+     */
+    items: PaywallFeatureItem[];
+    /**
+     * Points between the features.
+     */
+    spacing?: number;
+    /**
+     * The component.
+     */
+    type: "features";
+};
+/**
+ * An icon.
+ */
+export type PaywallIcon = {
+    /**
+     * Its color. A color of the theme (background, surface, text, muted, accent, on_accent, badge) — the light or the dark palette's, as the app appears —, or #RRGGBB / #RRGGBBAA in both.
+     */
+    color?: string;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    name: PaywallIconName;
+    /**
+     * Its size in points.
+     */
+    size?: number;
+    /**
+     * The component.
+     */
+    type: "icon";
+};
+/**
+ * An icon every renderer draws (SF Symbols on iOS).
+ */
+export type PaywallIconName = "ad_free" | "bell" | "bolt" | "book" | "chart" | "chat" | "check" | "check_circle" | "clock" | "cloud" | "crown" | "download" | "gift" | "globe" | "heart" | "infinity" | "lock_open" | "music" | "people" | "person" | "photo" | "shield" | "sparkles" | "star" | "video";
+/**
+ * An image the app downloads.
+ */
+export type PaywallImage = {
+    alt?: PaywallString;
+    /**
+     * Its frame's width over its height; the image's own when absent.
+     */
+    aspect?: number;
+    /**
+     * Its corner radius, in points.
+     */
+    corner?: number;
+    /**
+     * Fit shows it whole; fill covers the frame and crops.
+     */
+    fit?: "fit" | "fill";
+    /**
+     * Its frame's height in points; from its width when absent.
+     */
+    height?: number;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * Its https address.
+     */
+    src: string;
+    /**
+     * The component.
+     */
+    type: "image";
+};
+/**
+ * A link: the app's terms or privacy policy, or an https address.
+ */
+export type PaywallLink = {
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    text: PaywallString;
+    /**
+     * The component.
+     */
+    type: "link";
+    /**
+     * An https address, or `terms` / `privacy`: the addresses the app gives the SDK.
+     */
+    url: string;
+};
+/**
+ * The project's paywalls (at most 100), oldest first.
+ */
+export type PaywallList = {
+    /**
+     * The paywalls.
+     */
+    paywalls: PaywallSummary[];
+};
+/**
+ * The text itself, in every language.
+ */
+export type PaywallLiteral = string;
+/**
+ * The texts in each language (at most 40), by language tag: a component's `{"t": key}` is the app's language's, or the default locale's when it lacks the key.
+ */
+export type PaywallLocales = {
+    [key: string]: PaywallTexts;
+};
+/**
+ * A package: a product's plan of the catalog. The app shows it with its store's price (the response's offerings name each channel's store id).
+ */
+export type PaywallPackageItem = {
+    badge?: PaywallString;
+    detail?: PaywallString;
+    /**
+     * The product's plan.
+     */
+    plan: string;
+    /**
+     * The catalog's product.
+     */
+    product: string;
+    /**
+     * Selected when the paywall opens (at most one; the first when none is).
+     */
+    selected?: boolean;
+    title?: PaywallString;
+};
+/**
+ * The packages on sale, one of them selected: what the purchase button buys. A paywall has one.
+ */
+export type PaywallPackages = {
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * The packages, 1 to 6.
+     */
+    items: PaywallPackageItem[];
+    /**
+     * Rows down the screen, cards side by side, or a segmented picker.
+     */
+    layout?: "list" | "cards" | "segmented";
+    /**
+     * The component.
+     */
+    type: "packages";
+};
+/**
+ * One appearance's colors, each `#RRGGBB` or `#RRGGBBAA`. A component's color names one of them.
+ */
+export type PaywallPalette = {
+    /**
+     * The purchase button, the selected package, icons.
+     */
+    accent: string;
+    /**
+     * Behind everything.
+     */
+    background: string;
+    /**
+     * A package's badge.
+     */
+    badge: string;
+    /**
+     * Secondary text, the close button, dividers.
+     */
+    muted: string;
+    /**
+     * Text on the accent color.
+     */
+    on_accent: string;
+    /**
+     * Cards and the packages' background.
+     */
+    surface: string;
+    /**
+     * Text.
+     */
+    text: string;
+};
+/**
+ * One thing wrong with a definition.
+ */
+export type PaywallProblem = {
+    /**
+     * What it is (unknown_field, unknown_component, too_long, invalid_url, unknown_package …).
+     */
+    code: string;
+    /**
+     * What to do about it.
+     */
+    message: string;
+    /**
+     * Where it is (root.children[2].items[0].product).
+     */
+    path: string;
+    /**
+     * A warning does not stop a save or a publish (App Review's expectations, a package the catalog does not sell yet in a draft).
+     */
+    warning?: boolean;
+};
+/**
+ * purchases.paywall.published: a paywall's draft was published as its next version; the apps that ask for a placement showing it get it.
+ */
+export type PaywallPublishedEvent = {
+    /**
+     * Its name.
+     */
+    name: string;
+    /**
+     * The paywall.
+     */
+    paywall_id: string;
+    /**
+     * The schema it is written in.
+     */
+    schema: number;
+    /**
+     * The version published.
+     */
+    version: number;
+};
+/**
+ * The button that buys the selected package; the app's store sheet (StoreKit) or checkout (Stripe) opens.
+ */
+export type PaywallPurchaseButton = {
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    sub_text?: PaywallString;
+    text: PaywallString;
+    /**
+     * The component.
+     */
+    type: "purchase_button";
+};
+/**
+ * A definition to save as a paywall's draft.
+ */
+export type PaywallRequest = {
+    definition: PaywallDefinition;
+};
+/**
+ * The button that restores the customer's purchases from the store.
+ */
+export type PaywallRestoreButton = {
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    text?: PaywallString;
+    /**
+     * The component.
+     */
+    type: "restore_button";
+};
+/**
+ * Space: a fixed size, or all that is left along its stack when absent.
+ */
+export type PaywallSpacer = {
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * Its size in points.
+     */
+    size?: number;
+    /**
+     * The component.
+     */
+    type: "spacer";
+};
+/**
+ * Components laid out one after another — down, across — or over each other. The root is drawn in a scroll view.
+ */
+export type PaywallStack = {
+    /**
+     * Where the components sit across the axis (on both axes in a z stack); stretch fills it.
+     */
+    align?: "start" | "center" | "end" | "stretch";
+    /**
+     * Down the screen, across it, or over each other (z).
+     */
+    axis?: "vertical" | "horizontal" | "z";
+    /**
+     * Behind the stack; none when absent. A color of the theme (background, surface, text, muted, accent, on_accent, badge) — the light or the dark palette's, as the app appears —, or #RRGGBB / #RRGGBBAA in both.
+     */
+    background?: string;
+    /**
+     * The components, at most 50.
+     */
+    children?: PaywallComponent[];
+    /**
+     * The background's corner radius, in points.
+     */
+    corner?: number;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * Points around the components.
+     */
+    padding?: number;
+    /**
+     * Points between the components.
+     */
+    spacing?: number;
+    /**
+     * The component.
+     */
+    type: "stack";
+};
+/**
+ * A text: the string itself, or `{"t": key}` of the language table. Either may hold variables the app fills from its store — `{{price}}`, `{{price_per_month}}`, `{{period}}`, `{{trial}}`, `{{savings}}`, `{{product_name}}` — of the package an item is, or of the selected package anywhere else. A text that names a variable its package has no value for (no trial, no savings) is not drawn.
+ */
+export type PaywallString = PaywallLiteral | PaywallTextKey;
+/**
+ * A paywall in the project's list.
+ */
+export type PaywallSummary = {
+    /**
+     * Its draft's revision.
+     */
+    draft_revision: number;
+    /**
+     * The paywall's id.
+     */
+    id: string;
+    /**
+     * Its name.
+     */
+    name: string;
+    /**
+     * When the newest version was published.
+     */
+    published_at?: string;
+    /**
+     * The newest version published; 0 before the first.
+     */
+    published_version: number;
+    /**
+     * When the draft was last saved.
+     */
+    updated_at: string;
+};
+/**
+ * A text.
+ */
+export type PaywallText = {
+    /**
+     * Its alignment.
+     */
+    align?: "start" | "center" | "end";
+    /**
+     * Its color. A color of the theme (background, surface, text, muted, accent, on_accent, badge) — the light or the dark palette's, as the app appears —, or #RRGGBB / #RRGGBBAA in both.
+     */
+    color?: string;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * The platform's text style, scaled with the reader's text size.
+     */
+    style?: "large_title" | "title" | "headline" | "body" | "callout" | "caption" | "footnote";
+    text: PaywallString;
+    /**
+     * The component.
+     */
+    type: "text";
+    /**
+     * Its weight; the style's own when absent.
+     */
+    weight?: "regular" | "medium" | "semibold" | "bold";
+};
+/**
+ * A text of the language table.
+ */
+export type PaywallTextKey = {
+    /**
+     * The text's key.
+     */
+    t: string;
+};
+/**
+ * One language's texts, by key (lowercase letters, digits, `_` `.` `-`, at most 64): each at most 500 characters, with variables.
+ */
+export type PaywallTexts = {
+    [key: string]: string;
+};
+/**
+ * The paywall's colors in light and dark appearance, its corner radius and its type family.
+ */
+export type PaywallTheme = {
+    dark: PaywallPalette;
+    /**
+     * The type family: the platform's system font, its rounded or its serif design.
+     */
+    font?: "system" | "rounded" | "serif";
+    light: PaywallPalette;
+    /**
+     * The corner radius of cards, buttons and the packages, in points.
+     */
+    radius?: number;
+};
+/**
+ * A definition that passes, and what is left to say of it.
+ */
+export type PaywallValidation = {
+    /**
+     * The warnings, by path.
+     */
+    problems: PaywallProblem[];
 };
 /**
- * The paywall's catalog: the products on sale.
+ * A published version of a paywall.
  */
-export type Offerings = {
+export type PaywallVersion = {
+    definition?: PaywallDefinition;
     /**
-     * The products, each on the channels it is sold on.
+     * The paywall.
      */
-    products: Offering[];
+    paywall_id: string;
     /**
-     * The catalog's revision.
+     * When it was published.
      */
-    revision: number;
-};
-/**
- * What a quota spend took in credits past its limit.
- */
-export type OverflowReceipt = {
+    published_at: string;
     /**
-     * What is available of it after.
+     * Who published it (the key).
      */
-    available_after: number;
+    published_by: string;
     /**
-     * The credit's balance after.
+     * The schema it is written in.
      */
-    balance_after: number;
+    schema: number;
     /**
-     * Credits taken.
+     * The version: 1, 2, …
      */
-    committed: number;
+    version: number;
+};
+/**
+ * A page of a paywall's versions, newest first, without their definitions.
+ */
+export type PaywallVersions = {
     /**
-     * What it took, lot by lot.
+     * The next page's cursor; absent on the last.
      */
-    consumed: CreditConsumption[];
+    next_cursor?: string;
     /**
-     * The credit.
+     * The versions.
      */
-    currency: string;
+    versions: PaywallVersion[];
+};
+/**
+ * A place in an app a paywall is shown, as the app names it: the paywall it shows, or the experiment running on it.
+ */
+export type Placement = {
     /**
-     * Credits held.
+     * The experiment running on it.
      */
-    held: number;
+    experiment_id?: string;
     /**
-     * What a unit cost.
+     * The placement's key.
      */
-    per_unit: number;
+    key: string;
     /**
-     * Credits handed back.
+     * The paywall it shows; absent while an experiment runs on it.
      */
-    reversed: number;
+    paywall_id?: string;
     /**
-     * How many units went past the limit.
+     * When it was last given a paywall or an experiment.
      */
-    units: number;
+    updated_at: string;
+    /**
+     * Who did (the key).
+     */
+    updated_by: string;
 };
 /**
- * purchases.ownership.transferred: a purchase moved from one customer to another: the second restored the App Store purchases of the Apple ID it was made with.
+ * What an app draws at a placement: the paywall's newest version written in a schema the app draws, the subject's variant when an experiment runs there, and the store ids of what it sells — the app takes each price from its store (StoreKit, Stripe) and fills the variables with it.
  */
-export type OwnershipTransferredEvent = {
+export type PlacementPaywall = {
+    definition: PaywallDefinition;
+    offerings: Offerings;
     /**
-     * The purchase's id in the ledger.
+     * The paywall.
      */
-    chain_id: string;
+    paywall_id: string;
     /**
-     * Who had it.
+     * The placement.
      */
-    from_customer_id: string;
+    placement: string;
     /**
-     * The catalog's product; empty when unmapped.
+     * The schema the definition is written in: at most the one the app said it draws.
      */
-    product: string;
+    schema: number;
     /**
-     * Where it was bought.
+     * The subject's variant when an experiment runs on the placement; report it with the exposure. The same subject gets the same one every time.
      */
-    store: "app_store" | "play_store" | "stripe";
+    variant?: string;
     /**
-     * Who has it now.
+     * Its version; report it with the exposure.
      */
-    to_customer_id: string;
+    version: number;
+};
+/**
+ * The paywall a placement shows.
+ */
+export type PlacementRequest = {
     /**
-     * How.
+     * The paywall.
      */
-    via: "restore";
+    paywall_id: string;
+};
+/**
+ * The project's placements (at most 200), by key.
+ */
+export type Placements = {
+    /**
+     * The placements.
+     */
+    placements: Placement[];
 };
 /**
  * How a product is paid for.
@@ -1851,6 +2683,19 @@ export type RefundChangedEvent = {
      */
     transaction_id: string;
 };
+/**
+ * What was paid in one currency, net of what was refunded.
+ */
+export type Revenue = {
+    /**
+     * The amount in millionths of the currency's unit, as the stores report prices: the App Store's list price, Stripe's charged total, Google Play's recurring price.
+     */
+    amount_micros: number;
+    /**
+     * The currency (ISO 4217).
+     */
+    currency: string;
+};
 /**
  * The error envelope of a refused save, with every problem when the catalog breaks a rule (`invalid_catalog`).
  */
@@ -2281,6 +3126,60 @@ export type SubscriptionInfo = {
      */
     will_renew: boolean;
 };
+/**
+ * One variant's numbers.
+ */
+export type VariantResult = {
+    /**
+     * The probability that its conversion rate is the highest (0 to 1), Bayesian: each rate is Beta(1 + converters, 1 + viewers − converters) and the chance is how often its draw is the highest. It answers "how likely is this one best?" for any number of variants, at any sample, while the experiment runs.
+     */
+    chance_to_win: number;
+    /**
+     * converters over viewers. A viewer never signed in cannot be followed to a purchase: the rate is the same lower bound on every variant.
+     */
+    conversion_rate: number;
+    /**
+     * How many of its viewers made one.
+     */
+    converters: number;
+    /**
+     * How many times it was shown (a subject once in ten minutes).
+     */
+    exposures: number;
+    /**
+     * Its paywall.
+     */
+    paywall_id: string;
+    /**
+     * The purchases the stores confirmed (a subscription's start, a one-time product) that its viewers made within the window after first seeing it — each counted once, for the first variant its buyer saw.
+     */
+    purchases: number;
+    /**
+     * What its purchases were paid to date, renewals included, net of refunds, by currency.
+     */
+    revenue: Revenue[];
+    /**
+     * The variant.
+     */
+    variant: string;
+    /**
+     * How many subjects saw it: users, guests, and installations no one had signed in on.
+     */
+    viewers: number;
+    /**
+     * Its weight.
+     */
+    weight: number;
+};
+/**
+ * The variant that won.
+ */
+export type WinnerRequest = {
+    /**
+     * The variant's key.
+     */
+    variant: string;
+};
 /**
  * The certificate the environment takes Xcode's StoreKit Testing purchases signed with: test purchases made on a developer's Mac with no App Store at all, the sandbox's. It is public: Xcode saves it for whoever asks (Editor › Save Public Certificate).
  */
@@ -2353,6 +3252,10 @@ export interface Events {
      * purchases.ownership.transferred: a purchase moved from one customer to another: the second restored the App Store purchases of the Apple ID it was made with.
      */
     "purchases.ownership.transferred": OwnershipTransferredEvent;
+    /**
+     * purchases.paywall.published: a paywall's draft was published as its next version; the apps that ask for a placement showing it get it.
+     */
+    "purchases.paywall.published": PaywallPublishedEvent;
     /**
      * purchases.purchase.completed: a purchase new to the ledger: a subscription's start or a one-time product, in any store.
      */
@@ -2804,6 +3707,86 @@ export declare function client(t: Transport): {
         body?: SpendAction; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<200, SpendReceipt>>;
+    /**
+     * List the experiments
+     *
+     * The project's experiments, newest first, a page at a time; ?placement= keeps one placement's.
+     */
+    listExperiments(input?: {
+        query?: {
+            placement?: string; /** How many experiments a page holds (20 unless said). */
+            limit?: number; /** The `next_cursor` of the page before. */
+            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, Experiments>>;
+    /**
+     * Start an experiment
+     *
+     * Starts an experiment on a placement, making the placement when it is new: from then on the placement shows each subject — the signed-in user (a guest included), else the installation — its variant's paywall, the same every time (a hash of the experiment and the subject, placed on the weights; nothing is stored). Every variant's paywall must be published (422 `invalid_experiment`); one experiment runs on a placement at a time (409 `experiment_running`).
+     */
+    startExperiment(input: {
+        headers?: {
+            "Idempotency-Key"?: string;
+        };
+        body: ExperimentRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Experiment>>;
+    /**
+     * Read an experiment
+     *
+     * An experiment: its placement, its variants and its status.
+     */
+    getExperiment(input: {
+        path: {
+            experiment_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Experiment>>;
+    /**
+     * Read an experiment's results
+     *
+     * What each variant's audience did: exposures and viewers (distinct subjects); the purchases the stores confirmed that its viewers made within `window_days` (7 unless said) after first seeing it — the ledger's, never what an app reports — and how many viewers made one; the conversion rate; what was paid for them to date, net of refunds, by currency; and each variant's chance to convert best. `leader` is the likeliest best, `confident` whether declaring it the winner is sound. A store's test purchases count only with sandbox=true (a development environment's are all test purchases).
+     */
+    getExperimentResults(input: {
+        path: {
+            experiment_id: string;
+        };
+        query?: {
+            window_days?: number; /** Count the stores' test purchases too. */
+            sandbox?: boolean;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ExperimentResults>>;
+    /**
+     * Stop an experiment
+     *
+     * Stops a running experiment: the placement shows its first variant's paywall to everyone. Its results stay.
+     */
+    stopExperiment(input: {
+        path: {
+            experiment_id: string;
+        };
+        headers?: {
+            "Idempotency-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, Experiment>>;
+    /**
+     * Declare an experiment's winner
+     *
+     * Ends a running experiment with a winner: the placement shows the winner's paywall to everyone, at once. Its results stay.
+     */
+    declareExperimentWinner(input: {
+        path: {
+            experiment_id: string;
+        };
+        headers?: {
+            "Idempotency-Key"?: string;
+        };
+        body: WinnerRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Experiment>>;
     /**
      * Read what the customer has
      *
@@ -2840,6 +3823,192 @@ export declare function client(t: Transport): {
         }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<200, Offerings>>;
+    /**
+     * List the paywalls
+     *
+     * The project's paywalls, oldest first, with the newest version published of each.
+     */
+    listPaywalls(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PaywallList>>;
+    /**
+     * Make a paywall
+     *
+     * Makes a paywall with its first draft; nothing is published, and no app sees it until it is published and a placement shows it. The draft is checked as a draft: a rule broken refuses it (422 `invalid_paywall`, with every problem); a package the catalog does not sell yet is a warning. A project has at most 100 paywalls (409 `too_many_paywalls`).
+     */
+    createPaywall(input: {
+        headers?: {
+            "Idempotency-Key"?: string;
+        };
+        body: PaywallRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Paywall>>;
+    /**
+     * Check a paywall
+     *
+     * Checks a definition as publishing it would, without saving anything: every rule of its schema, and every package against the catalog as it is. A definition that passes is answered with its warnings (what App Review expects of a subscription's paywall: a restore button, the legal links); one that breaks a rule is refused with every problem (422 `invalid_paywall`).
+     */
+    validatePaywall(input: {
+        headers?: {
+            "Idempotency-Key"?: string;
+        };
+        body: PaywallDefinition; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PaywallValidation>>;
+    /**
+     * Read a paywall
+     *
+     * A paywall: its draft (the ETag is its revision), what was published of it, and what there is to say of the draft against the catalog as it is.
+     */
+    getPaywall(input: {
+        path: {
+            paywall_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Paywall>>;
+    /**
+     * Delete a paywall
+     *
+     * Deletes a paywall and its versions. A paywall a placement shows, or a running experiment does, is not deleted (409 `paywall_in_use`). What was counted of it stays in its experiments' results.
+     */
+    deletePaywall(input: {
+        path: {
+            paywall_id: string;
+        };
+        headers?: {
+            "Idempotency-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>>;
+    /**
+     * Save a paywall's draft
+     *
+     * Replaces the paywall's draft; what the apps show changes only when it is published. If-Match names the draft revision it was edited from: of two people editing at once, the second is told (412 `paywall_changed`), not overwritten. The draft is checked as a draft (422 `invalid_paywall`, with every problem).
+     */
+    savePaywallDraft(input: {
+        path: {
+            paywall_id: string;
+        };
+        headers: {
+            "If-Match": string; /** Makes the write safe to send again (at most 255 characters). A retry with the same key and the same request gets the first answer back, marked `Idempotent-Replayed: true`, and changes nothing; the same key with a different request is refused with 422, and while the first request still runs a retry gets 409 with Retry-After. Answers are kept for 24 hours. */
+            "Idempotency-Key"?: string;
+        };
+        body: PaywallRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Paywall>>;
+    /**
+     * Publish a paywall
+     *
+     * Publishes the paywall's draft as its next version, checked as the apps will get it: every package must be sold by the catalog (422 `invalid_paywall`, with every problem). If-Match names the draft revision that was looked at (412 `paywall_changed` when it moved since). The apps asking for a placement that shows the paywall get the new version at once — those whose SDK draws its schema. A draft the same as the newest version publishes nothing new (200). The newest 50 versions are kept, and the newest of each schema. Emits `purchases.paywall.published`.
+     */
+    publishPaywall(input: {
+        path: {
+            paywall_id: string;
+        };
+        headers: {
+            "If-Match": string; /** Makes the write safe to send again (at most 255 characters). A retry with the same key and the same request gets the first answer back, marked `Idempotent-Replayed: true`, and changes nothing; the same key with a different request is refused with 422, and while the first request still runs a retry gets 409 with Retry-After. Answers are kept for 24 hours. */
+            "Idempotency-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, PaywallVersion> | Reply<201, PaywallVersion>>;
+    /**
+     * List a paywall's versions
+     *
+     * The paywall's published versions, newest first, a page at a time, without their definitions.
+     */
+    listPaywallVersions(input: {
+        path: {
+            paywall_id: string;
+        };
+        query?: {
+            limit?: number; /** The `next_cursor` of the page before. */
+            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, PaywallVersions>>;
+    /**
+     * Read a paywall's version
+     *
+     * A published version, its definition as it was published.
+     */
+    getPaywallVersion(input: {
+        path: {
+            paywall_id: string; /** The version. */
+            version: number;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PaywallVersion>>;
+    /**
+     * List the placements
+     *
+     * The project's placements, by key: the paywall each shows, or the experiment running on it.
+     */
+    listPlacements(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Placements>>;
+    /**
+     * Give a placement a paywall
+     *
+     * Gives a placement a paywall, making the placement when it is new. The apps that ask for it get the paywall's newest version they can draw; a paywall never published is nothing yet (they get 204 and draw their own). While an experiment runs on the placement, the experiment decides (409 `experiment_running`). A project has at most 200 placements (409 `too_many_placements`).
+     */
+    setPlacement(input: {
+        path: {
+            placement: string;
+        };
+        headers?: {
+            "Idempotency-Key"?: string;
+        };
+        body: PlacementRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Placement>>;
+    /**
+     * Delete a placement
+     *
+     * Forgets a placement: the apps that ask for it get nothing (404) and draw their own. Not while an experiment runs on it (409 `experiment_running`).
+     */
+    deletePlacement(input: {
+        path: {
+            placement: string;
+        };
+        headers?: {
+            "Idempotency-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>>;
+    /**
+     * Report a paywall shown
+     *
+     * Counts that the app showed a version of a paywall at a placement, to the signed-in user (a guest included) or else the installation (X-Palbase-Installation; 400 `installation_required` without either). It is counted for an experiment's variant when it is the subject's variant on the placement's running experiment; a copy the app kept from before is counted for the paywall alone. The same subject, paywall version and placement count once in ten minutes; in a project, one address (an IPv6 /64 is one) reports at most 60 a minute, and at most 20 a minute are taken for one subject (429 `too_many_exposures`, Retry-After); another project's are its own, and reading the placement's paywall is never limited by them. Purchases are never reported here: they are the ones the stores confirmed, read from the ledger.
+     */
+    recordPaywallExposure(input: {
+        path: {
+            placement: string;
+        };
+        headers?: {
+            "X-Palbase-Installation"?: string;
+        };
+        body: ExposureRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Read a placement's paywall
+     *
+     * What an app draws at a placement. The app says the newest paywall schema its SDK draws (X-Palbase-Paywall-Schema; 1 when absent) and is given the newest version of the placement's paywall written in it or an older one: an app on an older SDK keeps getting the last version it can draw. When there is none — the paywall never published, or only in newer schemas — the answer is 204 and the app draws its own (from the offerings). While an experiment runs on the placement, the subject — the signed-in user (a guest included), else the installation (X-Palbase-Installation) — gets its variant, the same every time; without either the first variant is drawn, in no experiment. `offerings` are what the paywall sells, each channel's store ids (`?channel=` keeps one): the app prices them from its store. The ETag names the answer: sent back as If-None-Match, an unchanged one is 304. Any of the project's keys reads it, the publishable one included.
+     */
+    getPlacementPaywall(input: {
+        path: {
+            placement: string;
+        };
+        query?: {
+            channel?: "ios" | "android" | "web";
+        };
+        headers?: {
+            "X-Palbase-Paywall-Schema"?: number; /** The installation's id, as the SDK keeps it: who the paywall is shown to before anyone signs in. A signed-in user (a guest included) is who it is shown to, the installation aside. */
+            "X-Palbase-Installation"?: string; /** The ETag of the answer the app holds (a header over 1 KiB is not read). */
+            "If-None-Match"?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PlacementPaywall> | Reply<204, undefined> | Reply<304, undefined>>;
     /**
      * Read the settings
      *