palbase 0.2.0 → 0.3.0

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

@@ -540,6 +540,48 @@ export type CheckoutRequest = {
      */
     success_url: string;
 };
+/**
+ * What calling a leader takes — every variant seen by min_viewers subjects, the leader's chance to win min_chance — and what the results still lack, reason by reason: none, they are confident.
+ */
+export type Confidence = {
+    /**
+     * The chance to win the leader needs (0 to 1).
+     */
+    min_chance: number;
+    /**
+     * The subjects each variant needs to have been seen by.
+     */
+    min_viewers: number;
+    /**
+     * What is still lacking; empty when confident.
+     */
+    reasons: ConfidenceReason[];
+};
+/**
+ * One thing the results lack to call their leader.
+ */
+export type ConfidenceReason = {
+    /**
+     * Its chance to win, for leader_unsure.
+     */
+    chance?: number;
+    /**
+     * no_viewers: no one saw a variant yet; too_few_viewers: a variant was seen by fewer than min_viewers (variant, viewers); leader_unsure: the leader's chance to win is under min_chance (variant, chance).
+     */
+    code: "no_viewers" | "too_few_viewers" | "leader_unsure";
+    /**
+     * The reason in words ("variant b has 40 viewers (needs 100)").
+     */
+    message: string;
+    /**
+     * The variant it is about.
+     */
+    variant?: string;
+    /**
+     * Its viewers, for too_few_viewers.
+     */
+    viewers?: number;
+};
 /**
  * An In-App Purchase key handed over with a grant, for one of the environment's iOS apps.
  */
@@ -1091,6 +1133,10 @@ export type ErrorResponse = {
  * An experiment on a placement. Its variants never change while it runs, so no one's variant does.
  */
 export type Experiment = {
+    /**
+     * placement: everyone at the placement, decided before its rules; rules: the viewers the rules targeting it send it.
+     */
+    audience: "placement" | "rules";
     /**
      * When it ended.
      */
@@ -1120,7 +1166,7 @@ export type Experiment = {
      */
     started_by: string;
     /**
-     * running; stopped (the placement shows the first variant's paywall); won (the winner's).
+     * running; stopped (what it showed becomes the first variant's paywall); won (the winner's).
      */
     status: "running" | "stopped" | "won";
     /**
@@ -1136,12 +1182,16 @@ export type Experiment = {
  * An experiment to start.
  */
 export type ExperimentRequest = {
+    /**
+     * placement (when none): everyone at the placement — made when new —, decided before its rules; rules: the viewers the placement's rules targeting it send it — the placement is one already.
+     */
+    audience?: "placement" | "rules";
     /**
      * Its name (1 to 100 characters).
      */
     name: string;
     /**
-     * The placement it runs on (made when new).
+     * The placement it runs on (for everyone there, made when new).
      */
     placement: string;
     /**
@@ -1157,8 +1207,9 @@ export type ExperimentResults = {
      * When the numbers were counted.
      */
     computed_at: string;
+    confidence: Confidence;
     /**
-     * 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.
+     * Whether declaring the leader the winner is sound: confidence has no reason left.
      */
     confident: boolean;
     /**
@@ -1217,7 +1268,7 @@ export type Experiments = {
     next_cursor?: string;
 };
 /**
- * What an app showed at a placement, as it was given it.
+ * What an app showed at a placement, as it was given it. variant and rule_id are claims, checked against the placement: one that does not hold is not written.
  */
 export type ExposureRequest = {
     /**
@@ -1225,7 +1276,11 @@ export type ExposureRequest = {
      */
     paywall_id: string;
     /**
-     * The variant it was given, when an experiment runs on the placement.
+     * The rule the answer named, when it named one.
+     */
+    rule_id?: string;
+    /**
+     * The variant the answer named, when it named one.
      */
     variant?: string;
     /**
@@ -1642,438 +1697,1006 @@ export type Paywall = {
     updated_by: string;
 };
 /**
- * The button that closes the paywall.
+ * What a button does.
  */
-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;
+export type PaywallAction = {
     /**
-     * The component.
+     * Package.
      */
-    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 = {
+    package?: string;
     /**
-     * The language a text falls back to: a tag such as en or pt-BR.
+     * Sheet.
      */
-    default_locale: string;
-    locales?: PaywallLocales;
+    sheet?: string;
     /**
-     * The paywall's name, for the people who edit it (1 to 100 characters).
+     * Type.
      */
-    name: string;
-    root: PaywallComponent;
+    type: "close" | "restore" | "open_url" | "terms" | "privacy" | "offer_code" | "sheet" | "select_package";
     /**
-     * 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.
+     * Url.
      */
-    schema: number;
-    theme: PaywallTheme;
+    url?: string;
 };
 /**
- * A thin line across its stack.
+ * How the component appears; a renderer skips it when the system asks to reduce motion.
  */
-export type PaywallDivider = {
+export type PaywallAnimation = {
     /**
-     * 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.
+     * Delay ms.
      */
-    color?: string;
+    delay_ms?: number;
     /**
-     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     * Duration ms.
      */
-    id?: string;
+    duration_ms?: number;
     /**
-     * The component.
+     * Easing.
      */
-    type: "divider";
+    easing?: "ease_out" | "ease_in_out" | "spring";
+    /**
+     * Type.
+     */
+    type: "fade" | "slide_up" | "slide_down" | "slide_leading" | "slide_trailing" | "scale";
 };
 /**
- * The error envelope of a refused definition, with every problem when it breaks a rule (`invalid_paywall`).
+ * An image, a video, a font or an HTML block the project keeps in its own storage — a public bucket — and registered for its paywalls. A definition names it asset:<id>.
  */
-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[];
+export type PaywallAsset = {
     /**
-     * Correlation ID for log/audit lookup
+     * The project's bucket it is in: paywall-assets.
      */
-    request_id: string;
+    bucket: string;
     /**
-     * Seconds to wait before retrying; present on a refusal that ends with time.
+     * Its size.
      */
-    retry_after?: number;
+    bytes: number;
     /**
-     * HTTP status code (mirrors the response status)
+     * Its content type, from its bytes.
      */
-    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 = {
+    content_type: string;
     /**
-     * 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.
+     * When it was registered.
      */
-    color?: string;
+    created_at: 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.
+     * Who registered it (the key).
      */
-    icon_color?: string;
+    created_by: string;
     /**
-     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     * An HTML block's files.
      */
-    id?: string;
+    files?: number;
     /**
-     * The features, 1 to 12.
+     * The asset's id.
      */
-    items: PaywallFeatureItem[];
+    id: string;
     /**
-     * Points between the features.
+     * What its bytes are: an image (png, jpeg, webp), a video (mp4, mov), a font (ttf, otf, woff2), or an HTML block's zip.
      */
-    spacing?: number;
+    kind: "image" | "video" | "font" | "html";
     /**
-     * The component.
+     * What an HTML block's files hold together.
      */
-    type: "features";
-};
-/**
- * An icon.
- */
-export type PaywallIcon = {
+    opened_bytes?: number;
     /**
-     * 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.
+     * Its path in the bucket.
      */
-    color?: string;
+    path: string;
     /**
-     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     * How a definition names it: asset:<id>.
      */
-    id?: string;
-    name: PaywallIconName;
+    ref: string;
     /**
-     * Its size in points.
+     * The SHA-256 of its bytes, hex: an app draws what it downloads only when it is this.
      */
-    size?: number;
+    sha256: string;
     /**
-     * The component.
+     * Its public https address.
      */
-    type: "icon";
+    url: string;
 };
 /**
- * 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.
+ * An asset a definition names, as an app downloads it before it shows the paywall.
  */
-export type PaywallImage = {
-    alt?: PaywallString;
-    /**
-     * Its frame's width over its height; the image's own when absent.
-     */
-    aspect?: number;
+export type PaywallAssetRef = {
     /**
-     * Its corner radius, in points.
+     * Its size.
      */
-    corner?: number;
+    bytes: number;
     /**
-     * Fit shows it whole; fill covers the frame and crops.
+     * The asset: a definition names it asset:<id>.
      */
-    fit?: "fit" | "fill";
+    id: string;
     /**
-     * Its frame's height in points; from its width when absent.
+     * What it is.
      */
-    height?: number;
+    kind: "image" | "video" | "font" | "html";
     /**
-     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     * The SHA-256 its bytes must have: an asset whose download is not this is not drawn.
      */
-    id?: string;
+    sha256: string;
     /**
      * Its https address.
      */
-    src: string;
-    /**
-     * The component.
-     */
-    type: "image";
+    url: string;
 };
 /**
- * A link: the app's terms or privacy policy, or an https address.
+ * An object of the project's public bucket paywall-assets to register, uploaded first with the project's storage (palbase-js). Studio and the CLI make the bucket (public) when it is missing; the module reads nothing else.
  */
-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;
+export type PaywallAssetRequest = {
     /**
-     * The component.
+     * What the object is meant to be: a registration whose bytes are another kind is refused (asset_kind_mismatch).
      */
-    type: "link";
+    kind?: "image" | "video" | "font" | "html";
     /**
-     * An https address, or `terms` / `privacy`: the addresses the app gives the SDK.
+     * The object's path in the paywall-assets bucket (a leading / is the bucket's root). A . or .. segment, an empty one or a control character is refused, never resolved.
      */
-    url: string;
+    path: string;
 };
 /**
- * The project's paywalls (at most 100), oldest first.
+ * The project's paywall assets (at most 500), newest first.
  */
-export type PaywallList = {
+export type PaywallAssets = {
     /**
-     * The paywalls.
+     * The assets.
      */
-    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;
+    assets: PaywallAsset[];
 };
 /**
- * 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).
+ * A border.
  */
-export type PaywallPackageItem = {
-    badge?: PaywallString;
-    detail?: PaywallString;
+export type PaywallBorder = {
     /**
-     * The product's plan.
-     */
-    plan: string;
-    /**
-     * The catalog's product.
+     * Color.
      */
-    product: string;
+    color: string;
     /**
-     * Selected when the paywall opens (at most one; the first when none is).
+     * Width.
      */
-    selected?: boolean;
-    title?: PaywallString;
+    width: number;
 };
 /**
- * The packages on sale, one of them selected: what the purchase button buys. A paywall has one.
+ * A button that does an action: closes the paywall, restores purchases, opens an address, the terms or the privacy policy, the store's offer code sheet, one of the paywall's sheets, or selects a package.
  */
-export type PaywallPackages = {
+export type PaywallButton = {
+    action: PaywallAction;
+    animation?: PaywallAnimation;
+    content: PaywallComponent;
     /**
      * 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";
+    states?: PaywallStates;
+    style?: PaywallStyle;
     /**
      * The component.
      */
-    type: "packages";
+    type: "button";
+    visible?: PaywallCondition;
 };
 /**
- * One appearance's colors, each `#RRGGBB` or `#RRGGBBAA`. A component's color names one of them.
+ * Pages the customer swipes through, the next peeking in, advancing on their own, with an indicator.
  */
-export type PaywallPalette = {
+export type PaywallCarousel = {
+    animation?: PaywallAnimation;
     /**
-     * The purchase button, the selected package, icons.
+     * Auto advance ms.
      */
-    accent: string;
+    auto_advance_ms?: number;
     /**
-     * Behind everything.
+     * Height.
      */
-    background: string;
+    height?: PaywallSizeKeyword | PaywallLength;
     /**
-     * A package's badge.
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    indicator?: PaywallIndicator;
+    /**
+     * Loop.
      */
-    badge: string;
+    loop?: boolean;
     /**
-     * Secondary text, the close button, dividers.
+     * Pages.
      */
-    muted: string;
+    pages: PaywallComponent[];
     /**
-     * Text on the accent color.
+     * Peek.
      */
-    on_accent: string;
+    peek?: number;
     /**
-     * Cards and the packages' background.
+     * Spacing.
      */
-    surface: string;
+    spacing?: number;
+    states?: PaywallStates;
+    style?: PaywallStyle;
     /**
-     * Text.
+     * The component.
      */
-    text: string;
+    type: "carousel";
+    visible?: PaywallCondition;
 };
 /**
- * One thing wrong with a definition.
+ * A color: a token of the theme's colors (the light or the dark value, as the app appears), or #RRGGBB / #RRGGBBAA.
  */
-export type PaywallProblem = {
+export type PaywallColorValue = string;
+/**
+ * The theme's colors by name, for each appearance; both name the same colors, at least background, surface, text, muted, accent and on_accent.
+ */
+export type PaywallColors = {
+    dark: PaywallPalette;
+    light: PaywallPalette;
+};
+/**
+ * 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 = PaywallButton | PaywallCarousel | PaywallCountdown | PaywallCustomHtml | PaywallDivider | PaywallFeatures | PaywallIcon | PaywallImage | PaywallPackage | PaywallPurchaseButton | PaywallSpacer | PaywallStack | PaywallSwitch | PaywallTabs | PaywallText | PaywallTimeline | PaywallVideo;
+/**
+ * When the component is shown: every field named holds at once.
+ */
+export type PaywallCondition = {
     /**
-     * What it is (unknown_field, unknown_component, too_long, invalid_url, unknown_package …).
+     * Appearance.
      */
-    code: string;
+    appearance?: "light" | "dark";
     /**
-     * What to do about it.
+     * Intro eligible.
      */
-    message: string;
+    intro_eligible?: boolean;
     /**
-     * Where it is (root.children[2].items[0].product).
+     * Locale.
      */
-    path: string;
+    locale?: 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).
+     * Platform.
      */
-    warning?: boolean;
+    platform?: ("ios" | "android" | "web")[];
+    /**
+     * Selected package.
+     */
+    selected_package?: string[];
+    /**
+     * Tab.
+     */
+    tab?: string;
 };
 /**
- * purchases.paywall.published: a paywall's draft was published as its next version; the apps that ask for a placement showing it get it.
+ * Each corner its own, in points or a token of the theme's radii.
  */
-export type PaywallPublishedEvent = {
+export type PaywallCorners = {
     /**
-     * Its name.
+     * Bottom leading.
      */
-    name: string;
+    bottom_leading?: PaywallPoints | PaywallToken;
     /**
-     * The paywall.
+     * Bottom trailing.
      */
-    paywall_id: string;
+    bottom_trailing?: PaywallPoints | PaywallToken;
     /**
-     * The schema it is written in.
+     * Top leading.
      */
-    schema: number;
+    top_leading?: PaywallPoints | PaywallToken;
     /**
-     * The version published.
+     * Top trailing.
      */
-    version: number;
+    top_trailing?: PaywallPoints | PaywallToken;
 };
 /**
- * The button that buys the selected package; the app's store sheet (StoreKit) or checkout (Stripe) opens.
+ * A countdown to an instant, or for a time from the moment the paywall opened: one content while it counts — its texts name {{countdown}}, {{days}}, {{hours}}, {{minutes}}, {{seconds}} —, another once it ended.
  */
-export type PaywallPurchaseButton = {
+export type PaywallCountdown = {
+    animation?: PaywallAnimation;
+    counting: PaywallComponent;
+    ended?: PaywallComponent;
     /**
      * 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;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    target: PaywallTarget;
     /**
      * The component.
      */
-    type: "purchase_button";
-};
-/**
- * A definition to save as a paywall's draft.
- */
-export type PaywallRequest = {
-    definition: PaywallDefinition;
+    type: "countdown";
+    visible?: PaywallCondition;
 };
 /**
- * The button that restores the customer's purchases from the store.
+ * A decorative HTML block from an archive the project uploaded (an animation, a Lottie or Rive scene): drawn in a sandbox of an origin of its own: it reaches neither the page around it, nor the app, nor the purchase, and loads only what came in its archive (a content security policy) — it may still navigate its own frame away. It is told the selected package, the language and the appearance, and is hidden from screen readers. It cannot buy anything.
  */
-export type PaywallRestoreButton = {
+export type PaywallCustomHtml = {
+    animation?: PaywallAnimation;
+    /**
+     * Height.
+     */
+    height: PaywallSizeKeyword | PaywallLength;
     /**
      * Names the component, unique in the paywall: an app's code can draw its own part in its place.
      */
     id?: string;
-    text?: PaywallString;
+    /**
+     * Src.
+     */
+    src: string;
+    states?: PaywallStates;
+    style?: PaywallStyle;
     /**
      * The component.
      */
-    type: "restore_button";
+    type: "custom_html";
+    visible?: PaywallCondition;
 };
 /**
- * Space: a fixed size, or all that is left along its stack when absent.
+ * A paywall: a design system (the theme's colors, type scale, radii and spacing) and a free layout of components that name it — a fixed header and footer around the part that scrolls, and sheets it opens. Every component takes a style, a condition to be shown, a style for when it is selected, and an entrance animation. Prices are never in it: an app fills `{{price}}` and the other variables from its store. Its assets (asset:<id>) are the project's, given as https addresses in the app's answer and listed for the app to download before it shows the paywall. The server refuses what it does not know and holds a definition to bounds: 128 KiB of JSON, 400 components, 16 deep, 500 characters a text, 40 languages, 8 stops a gradient, 2 seconds an animation, 10 carousel pages, 5 tabs, 5 sheets.
  */
-export type PaywallSpacer = {
+export type PaywallDefinition = {
     /**
-     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     * The language a text falls back to: a tag such as en or pt-BR.
      */
-    id?: string;
+    default_locale: string;
+    footer?: PaywallComponent;
+    header?: PaywallComponent;
+    locales?: PaywallLocales;
     /**
-     * Its size in points.
+     * The paywall's name, for the people who edit it (1 to 100 characters).
      */
-    size?: number;
+    name: string;
+    root: PaywallComponent;
     /**
-     * The component.
+     * The schema the definition is written in: 2. An app says the newest schema it draws (X-Palbase-Paywall-Schema) and is given the newest version written in it or an older one; an app that draws no schema this server takes is told to update (426).
      */
-    type: "spacer";
+    schema: number;
+    sheets?: PaywallSheets;
+    theme: PaywallTheme;
 };
 /**
- * Components laid out one after another — down, across — or over each other. The root is drawn in a scroll view.
+ * A thin line across its stack.
  */
-export type PaywallStack = {
+export type PaywallDivider = {
+    animation?: PaywallAnimation;
     /**
-     * Where the components sit across the axis (on both axes in a z stack); stretch fills it.
+     * Color.
      */
-    align?: "start" | "center" | "end" | "stretch";
+    color?: string;
     /**
-     * Down the screen, across it, or over each other (z).
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
      */
-    axis?: "vertical" | "horizontal" | "z";
+    id?: string;
+    states?: PaywallStates;
+    style?: PaywallStyle;
     /**
-     * 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.
+     * Thickness.
      */
-    background?: string;
+    thickness?: number;
     /**
-     * The components, at most 50.
+     * The component.
      */
-    children?: PaywallComponent[];
+    type: "divider";
+    visible?: PaywallCondition;
+};
+/**
+ * Each edge its own, in points or a token of the theme's spacing.
+ */
+export type PaywallEdges = {
     /**
-     * The background's corner radius, in points.
+     * Bottom.
      */
-    corner?: number;
+    bottom?: PaywallPoints | PaywallToken;
     /**
-     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     * Leading.
      */
-    id?: string;
+    leading?: PaywallPoints | PaywallToken;
     /**
-     * Points around the components.
+     * Top.
      */
-    padding?: number;
+    top?: PaywallPoints | PaywallToken;
     /**
-     * Points between the components.
+     * Trailing.
      */
-    spacing?: number;
-    /**
+    trailing?: PaywallPoints | PaywallToken;
+};
+/**
+ * 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 PaywallFeature = {
+    icon: PaywallIconName;
+    text: PaywallString;
+};
+/**
+ * What the purchase gives, each with an icon.
+ */
+export type PaywallFeatures = {
+    animation?: PaywallAnimation;
+    /**
+     * Color.
+     */
+    color?: string;
+    /**
+     * Icon color.
+     */
+    icon_color?: string;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * Items.
+     */
+    items: PaywallFeature[];
+    /**
+     * Spacing.
+     */
+    spacing?: number;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * The component.
+     */
+    type: "features";
+    visible?: PaywallCondition;
+};
+/**
+ * A size in points, scaled with the platform's body style.
+ */
+export type PaywallFontSize = number;
+/**
+ * An icon every renderer draws.
+ */
+export type PaywallIcon = {
+    animation?: PaywallAnimation;
+    /**
+     * Color.
+     */
+    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;
+    /**
+     * Size.
+     */
+    size?: number;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * The component.
+     */
+    type: "icon";
+    visible?: PaywallCondition;
+};
+/**
+ * An icon every renderer draws (SF Symbols on iOS).
+ */
+export type PaywallIconName = "ad_free" | "arrow_right" | "bell" | "bolt" | "book" | "calendar" | "chart" | "chat" | "check" | "check_circle" | "clock" | "close" | "cloud" | "crown" | "download" | "gift" | "globe" | "heart" | "infinity" | "lock" | "lock_open" | "music" | "people" | "person" | "photo" | "play" | "quote" | "shield" | "sparkles" | "star" | "trophy" | "video";
+/**
+ * An image the app downloads before it shows the paywall: an https address, or an image the project uploaded.
+ */
+export type PaywallImage = {
+    alt?: PaywallString;
+    animation?: PaywallAnimation;
+    /**
+     * Aspect.
+     */
+    aspect?: number;
+    /**
+     * Decorative.
+     */
+    decorative?: boolean;
+    /**
+     * Fit.
+     */
+    fit?: "fit" | "fill";
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    mask?: PaywallMask;
+    /**
+     * Overlay.
+     */
+    overlay?: PaywallLinear | PaywallRadial;
+    /**
+     * Src.
+     */
+    src: string;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * The component.
+     */
+    type: "image";
+    visible?: PaywallCondition;
+};
+/**
+ * An image behind the component.
+ */
+export type PaywallImageFill = {
+    /**
+     * Fit.
+     */
+    fit?: "fit" | "fill";
+    /**
+     * Src.
+     */
+    src: string;
+    /**
+     * Type.
+     */
+    type: "image";
+};
+/**
+ * A carousel's page indicator.
+ */
+export type PaywallIndicator = {
+    /**
+     * Active color.
+     */
+    active_color?: string;
+    /**
+     * Color.
+     */
+    color?: string;
+    /**
+     * Size.
+     */
+    size?: number;
+    /**
+     * Spacing.
+     */
+    spacing?: number;
+    /**
+     * Its style.
+     */
+    style?: "dots" | "bars" | "none";
+};
+/**
+ * A length in points.
+ */
+export type PaywallLength = number;
+/**
+ * A linear gradient: its angle (0 up, clockwise, 180 down) and 2 to 8 stops.
+ */
+export type PaywallLinear = {
+    /**
+     * Angle.
+     */
+    angle?: number;
+    /**
+     * Stops.
+     */
+    stops: PaywallStop[];
+    /**
+     * Type.
+     */
+    type: "linear";
+};
+/**
+ * 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;
+};
+/**
+ * The image's shape: a rectangle with corners, a circle, or a rectangle whose bottom edge curves in (concave) or out (convex).
+ */
+export type PaywallMask = {
+    /**
+     * Depth.
+     */
+    depth?: number;
+    /**
+     * Radius.
+     */
+    radius?: PaywallPoints | PaywallToken;
+    /**
+     * Shape.
+     */
+    shape: "rect" | "circle" | "concave" | "convex";
+};
+/**
+ * A package on sale, laid out as the project likes: tapping it selects it; its content's styles for when it is selected apply while it is.
+ */
+export type PaywallPackage = {
+    animation?: PaywallAnimation;
+    /**
+     * The components.
+     */
+    children?: PaywallComponent[];
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * Plan.
+     */
+    plan: string;
+    /**
+     * Product.
+     */
+    product: string;
+    /**
+     * Selected when the paywall opens (at most one).
+     */
+    selected?: boolean;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * The component.
+     */
+    type: "package";
+    visible?: PaywallCondition;
+};
+/**
+ * Colors by token (lowercase letters, digits and _, at most 32), each #RRGGBB or #RRGGBBAA.
+ */
+export type PaywallPalette = {
+    [key: string]: string;
+};
+/**
+ * Points.
+ */
+export type PaywallPoints = number;
+/**
+ * One thing wrong with a definition.
+ */
+export type PaywallProblem = {
+    /**
+     * What it is (unknown_field, unknown_component, too_long, invalid_url, unknown_package, unknown_token, unknown_asset, asset_missing, asset_changed, asset_unverified …).
+     */
+    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 — or its own package —: the store's sheet (StoreKit) or checkout (Stripe) opens.
+ */
+export type PaywallPurchaseButton = {
+    animation?: PaywallAnimation;
+    content: PaywallComponent;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * Package.
+     */
+    package?: string;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * The component.
+     */
+    type: "purchase_button";
+    visible?: PaywallCondition;
+};
+/**
+ * A radial gradient: its center and radius as shares of the component, and 2 to 8 stops.
+ */
+export type PaywallRadial = {
+    /**
+     * Center x.
+     */
+    center_x?: number;
+    /**
+     * Center y.
+     */
+    center_y?: number;
+    /**
+     * Radius.
+     */
+    radius?: number;
+    /**
+     * Stops.
+     */
+    stops: PaywallStop[];
+    /**
+     * Type.
+     */
+    type: "radial";
+};
+/**
+ * A definition to save as a paywall's draft.
+ */
+export type PaywallRequest = {
+    definition: PaywallDefinition;
+};
+/**
+ * Points by token (lowercase letters, digits and _, at most 32).
+ */
+export type PaywallScale = {
+    [key: string]: number;
+};
+/**
+ * The error envelope of an app whose SDK draws no paywall schema this server takes (`paywall_schema_too_old`): it draws its own paywall, and updating the SDK shows the project's.
+ */
+export type PaywallSchemaError = {
+    /**
+     * Machine-readable error code (snake_case)
+     */
+    error: string;
+    /**
+     * Human-readable explanation
+     */
+    error_description: string;
+    /**
+     * The oldest schema an SDK must draw to be given this project's paywalls.
+     */
+    min_schema: number;
+    /**
+     * Correlation ID for log/audit lookup
+     */
+    request_id: string;
+    /**
+     * HTTP status code (mirrors the response status)
+     */
+    status: number;
+};
+/**
+ * A shadow.
+ */
+export type PaywallShadow = {
+    /**
+     * Color.
+     */
+    color: string;
+    /**
+     * Radius.
+     */
+    radius?: number;
+    /**
+     * X.
+     */
+    x?: number;
+    /**
+     * Y.
+     */
+    y?: number;
+};
+/**
+ * A second page a button opens over the paywall.
+ */
+export type PaywallSheet = {
+    root: PaywallComponent;
+    title?: PaywallString;
+};
+/**
+ * The sheets by id (lowercase letters, digits, _ and -, starting with a letter).
+ */
+export type PaywallSheets = {
+    [key: string]: PaywallSheet;
+};
+/**
+ * fit: the content's size; fill: all the parent gives; a share of the parent ("50%").
+ */
+export type PaywallSizeKeyword = string;
+/**
+ * Space: a fixed size, or all that is left along its stack when absent.
+ */
+export type PaywallSpacer = {
+    animation?: PaywallAnimation;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * Size.
+     */
+    size?: PaywallPoints | PaywallToken;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * The component.
+     */
+    type: "spacer";
+    visible?: PaywallCondition;
+};
+/**
+ * A part of a text: bold, italic, underlined, struck through, colored, a link.
+ */
+export type PaywallSpan = {
+    /**
+     * Bold.
+     */
+    bold?: boolean;
+    /**
+     * Color.
+     */
+    color?: string;
+    /**
+     * Italic.
+     */
+    italic?: boolean;
+    /**
+     * Link.
+     */
+    link?: string;
+    /**
+     * Strikethrough.
+     */
+    strikethrough?: boolean;
+    text: PaywallString;
+    /**
+     * Underline.
+     */
+    underline?: boolean;
+};
+/**
+ * Components laid out one after another — down, across — or over each other (z). The root, the header and the footer are each one; the root scrolls between the fixed header and footer.
+ */
+export type PaywallStack = {
+    /**
+     * Align.
+     */
+    align?: "start" | "center" | "end" | "stretch";
+    animation?: PaywallAnimation;
+    /**
+     * Axis.
+     */
+    axis?: "vertical" | "horizontal" | "z";
+    /**
+     * The components.
+     */
+    children?: PaywallComponent[];
+    /**
+     * Distribution.
+     */
+    distribution?: "start" | "center" | "end" | "space_between" | "space_around" | "space_evenly";
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * Scroll.
+     */
+    scroll?: boolean;
+    /**
+     * Spacing.
+     */
+    spacing?: PaywallPoints | PaywallToken;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
      * The component.
      */
     type: "stack";
+    visible?: PaywallCondition;
+};
+/**
+ * The component's style while what it is in is selected: the package it is in (or is), the tab whose label it is.
+ */
+export type PaywallStates = {
+    selected?: PaywallStyle;
+};
+/**
+ * A gradient's color at a point along it (0 to 1).
+ */
+export type PaywallStop = {
+    /**
+     * At.
+     */
+    at: number;
+    /**
+     * Color.
+     */
+    color: string;
 };
 /**
  * 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;
+/**
+ * What every component takes: padding and margin by edge, a size, a fill, a border, corners each their own, a shadow, an opacity. Points and colors name the theme's tokens or are given as they are.
+ */
+export type PaywallStyle = {
+    /**
+     * Background.
+     */
+    background?: PaywallColorValue | PaywallLinear | PaywallRadial | PaywallImageFill | PaywallVideoFill;
+    border?: PaywallBorder;
+    /**
+     * Corners.
+     */
+    corners?: PaywallPoints | PaywallToken | PaywallCorners;
+    /**
+     * Height.
+     */
+    height?: PaywallSizeKeyword | PaywallLength;
+    /**
+     * Margin.
+     */
+    margin?: PaywallPoints | PaywallToken | PaywallEdges;
+    /**
+     * Max width.
+     */
+    max_width?: number;
+    /**
+     * Opacity.
+     */
+    opacity?: number;
+    /**
+     * Padding.
+     */
+    padding?: PaywallPoints | PaywallToken | PaywallEdges;
+    shadow?: PaywallShadow;
+    /**
+     * Width.
+     */
+    width?: PaywallSizeKeyword | PaywallLength;
+};
 /**
  * A paywall in the project's list.
  */
@@ -2104,34 +2727,152 @@ export type PaywallSummary = {
     updated_at: string;
 };
 /**
- * A text.
+ * A switch between two contents — a yearly and a monthly offer —, each selecting its own package when it is shown.
+ */
+export type PaywallSwitch = {
+    animation?: PaywallAnimation;
+    /**
+     * Default.
+     */
+    default?: boolean;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    label?: PaywallString;
+    off: PaywallComponent;
+    /**
+     * Off package.
+     */
+    off_package?: string;
+    on: PaywallComponent;
+    /**
+     * On package.
+     */
+    on_package?: string;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * Tint.
+     */
+    tint?: string;
+    /**
+     * The component.
+     */
+    type: "switch";
+    visible?: PaywallCondition;
+};
+/**
+ * A tab: its label, its content, and the package it selects when it is shown.
+ */
+export type PaywallTab = {
+    content: PaywallComponent;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id: string;
+    label: PaywallComponent;
+    /**
+     * Package.
+     */
+    package?: string;
+};
+/**
+ * Tabs, each its own content and default package; the labels, in a bar, are components whose style when selected is the shown tab's.
+ */
+export type PaywallTabs = {
+    animation?: PaywallAnimation;
+    bar?: PaywallStyle;
+    /**
+     * Default.
+     */
+    default?: string;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * Tabs.
+     */
+    tabs: PaywallTab[];
+    /**
+     * The component.
+     */
+    type: "tabs";
+    visible?: PaywallCondition;
+};
+/**
+ * What a countdown counts to: an instant (at), or a time from the moment the paywall opened (after_open_seconds) — one of them.
+ */
+export type PaywallTarget = {
+    /**
+     * After open seconds.
+     */
+    after_open_seconds?: number;
+    /**
+     * At.
+     */
+    at?: string;
+};
+/**
+ * A text: one string, or spans — bold, italic, colored parts and links —, in a type style of the theme or its own.
  */
 export type PaywallText = {
     /**
-     * Its alignment.
+     * Align.
      */
     align?: "start" | "center" | "end";
+    animation?: PaywallAnimation;
     /**
-     * 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.
      */
-    color?: string;
+    color?: PaywallColorValue | PaywallLinear | PaywallRadial;
+    /**
+     * Font.
+     */
+    font?: 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.
+     * Letter spacing.
      */
-    style?: "large_title" | "title" | "headline" | "body" | "callout" | "caption" | "footnote";
-    text: PaywallString;
+    letter_spacing?: number;
+    /**
+     * Line height.
+     */
+    line_height?: number;
+    /**
+     * Max lines.
+     */
+    max_lines?: number;
+    /**
+     * Size.
+     */
+    size?: PaywallFontSize | PaywallToken;
+    /**
+     * Spans.
+     */
+    spans?: PaywallSpan[];
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    text?: PaywallString;
     /**
      * The component.
      */
     type: "text";
     /**
-     * Its weight; the style's own when absent.
+     * Uppercase.
+     */
+    uppercase?: boolean;
+    visible?: PaywallCondition;
+    /**
+     * Weight.
      */
-    weight?: "regular" | "medium" | "semibold" | "bold";
+    weight?: 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
 };
 /**
  * A text of the language table.
@@ -2149,19 +2890,105 @@ export type PaywallTexts = {
     [key: string]: string;
 };
 /**
- * The paywall's colors in light and dark appearance, its corner radius and its type family.
+ * The paywall's design system: colors for light and dark, a type scale, radii and spacing; the components name them.
  */
 export type PaywallTheme = {
-    dark: PaywallPalette;
+    colors: PaywallColors;
+    radii?: PaywallScale;
+    spacing?: PaywallScale;
+    typography?: PaywallTypeScale;
+};
+/**
+ * Steps in time — a trial's today, its reminder, its first charge —, each with an icon, joined by a line.
+ */
+export type PaywallTimeline = {
+    animation?: PaywallAnimation;
     /**
-     * The type family: the platform's system font, its rounded or its serif design.
+     * Color.
      */
-    font?: "system" | "rounded" | "serif";
-    light: PaywallPalette;
+    color?: string;
     /**
-     * The corner radius of cards, buttons and the packages, in points.
+     * Icon color.
      */
-    radius?: number;
+    icon_color?: string;
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * Items.
+     */
+    items: PaywallTimelineItem[];
+    /**
+     * Line color.
+     */
+    line_color?: string;
+    /**
+     * Line width.
+     */
+    line_width?: number;
+    /**
+     * Spacing.
+     */
+    spacing?: number;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * The component.
+     */
+    type: "timeline";
+    visible?: PaywallCondition;
+};
+/**
+ * A step of a timeline.
+ */
+export type PaywallTimelineItem = {
+    /**
+     * Color.
+     */
+    color?: string;
+    icon: PaywallIconName;
+    text?: PaywallString;
+    title: PaywallString;
+};
+/**
+ * A token of the theme's scale.
+ */
+export type PaywallToken = string;
+/**
+ * Type styles by token (lowercase letters, digits and _, at most 32).
+ */
+export type PaywallTypeScale = {
+    [key: string]: PaywallTypography;
+};
+/**
+ * A type style of the theme: what a text whose size names it is drawn in. It scales with its text style (Dynamic Type on iOS, the root font size on the web).
+ */
+export type PaywallTypography = {
+    /**
+     * Font.
+     */
+    font?: string;
+    /**
+     * Letter spacing.
+     */
+    letter_spacing?: number;
+    /**
+     * Line height.
+     */
+    line_height?: number;
+    /**
+     * Size.
+     */
+    size: number;
+    /**
+     * Text style.
+     */
+    text_style?: "large_title" | "title" | "title2" | "title3" | "headline" | "body" | "callout" | "subheadline" | "footnote" | "caption";
+    /**
+     * Weight.
+     */
+    weight?: 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
 };
 /**
  * A definition that passes, and what is left to say of it.
@@ -2190,33 +3017,104 @@ export type PaywallVersion = {
      */
     published_by: string;
     /**
-     * The schema it is written in.
+     * The schema it is written in.
+     */
+    schema: number;
+    /**
+     * The version: 1, 2, …
+     */
+    version: number;
+};
+/**
+ * A page of a paywall's versions, newest first, without their definitions.
+ */
+export type PaywallVersions = {
+    /**
+     * The next page's cursor; absent on the last.
+     */
+    next_cursor?: string;
+    /**
+     * The versions.
+     */
+    versions: PaywallVersion[];
+};
+/**
+ * A video the app downloads before it shows the paywall; muted and looping unless it says otherwise.
+ */
+export type PaywallVideo = {
+    alt?: PaywallString;
+    animation?: PaywallAnimation;
+    /**
+     * Aspect.
+     */
+    aspect?: number;
+    /**
+     * Autoplay.
+     */
+    autoplay?: boolean;
+    /**
+     * Controls.
+     */
+    controls?: boolean;
+    /**
+     * Fit.
+     */
+    fit?: "fit" | "fill";
+    /**
+     * Names the component, unique in the paywall: an app's code can draw its own part in its place.
+     */
+    id?: string;
+    /**
+     * Loop.
+     */
+    loop?: boolean;
+    /**
+     * Mute.
+     */
+    mute?: boolean;
+    /**
+     * Poster.
+     */
+    poster?: string;
+    /**
+     * Src.
      */
-    schema: number;
+    src: string;
+    states?: PaywallStates;
+    style?: PaywallStyle;
     /**
-     * The version: 1, 2, …
+     * The component.
      */
-    version: number;
+    type: "video";
+    visible?: PaywallCondition;
 };
 /**
- * A page of a paywall's versions, newest first, without their definitions.
+ * A muted video behind the component.
  */
-export type PaywallVersions = {
+export type PaywallVideoFill = {
     /**
-     * The next page's cursor; absent on the last.
+     * Loop.
      */
-    next_cursor?: string;
+    loop?: boolean;
     /**
-     * The versions.
+     * Poster.
      */
-    versions: PaywallVersion[];
+    poster?: string;
+    /**
+     * Src.
+     */
+    src: string;
+    /**
+     * Type.
+     */
+    type: "video";
 };
 /**
- * A place in an app a paywall is shown, as the app names it: the paywall it shows, or the experiment running on it.
+ * A place in an app a paywall is shown, as the app names it: its default paywall, the experiment running on it for everyone there, and how many rules it has.
  */
 export type Placement = {
     /**
-     * The experiment running on it.
+     * The experiment running on it for everyone there (audience placement).
      */
     experiment_id?: string;
     /**
@@ -2224,9 +3122,13 @@ export type Placement = {
      */
     key: string;
     /**
-     * The paywall it shows; absent while an experiment runs on it.
+     * Its default paywall: what it shows whoever none of its rules holds for. Absent while an experiment for everyone runs on a placement that had none.
      */
     paywall_id?: string;
+    /**
+     * How many rules it has (GET …/rules reads them).
+     */
+    rule_count: number;
     /**
      * When it was last given a paywall or an experiment.
      */
@@ -2237,9 +3139,13 @@ export type Placement = {
     updated_by: string;
 };
 /**
- * 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.
+ * What an app draws at a placement: the paywall's newest version written in a schema the app draws, where it came from (the experiment running for the whole placement, a rule, the placement's default) and the rule, the subject's variant when it is in an experiment, 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 PlacementPaywall = {
+    /**
+     * The project's assets the definition names (asset:<id>), each once: the app downloads them when it gets the paywall — before it shows it —, checks each one's SHA-256 and size, and draws an asset only from its checked download. One it could not get, or whose bytes are not these, it does without: an image is not drawn, a font is the system's, a video is its poster or the background's color, an HTML block is not drawn.
+     */
+    assets: PaywallAssetRef[];
     definition: PaywallDefinition;
     offerings: Offerings;
     /**
@@ -2250,12 +3156,20 @@ export type PlacementPaywall = {
      * The placement.
      */
     placement: string;
+    /**
+     * The rule that decided, when one did: report it with the exposure.
+     */
+    rule_id?: string;
     /**
      * The schema the definition is written in: at most the one the app said it draws.
      */
     schema: number;
     /**
-     * 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.
+     * Where it came from: experiment (the one running for the whole placement), rule, or default.
+     */
+    source: "experiment" | "rule" | "default";
+    /**
+     * The subject's variant when it is in an experiment; report it with the exposure. The same subject gets the same one every time.
      */
     variant?: string;
     /**
@@ -2263,6 +3177,36 @@ export type PlacementPaywall = {
      */
     version: number;
 };
+/**
+ * What the placement shows the viewer at the moment, where it came from, and what each rule came to.
+ */
+export type PlacementPreview = {
+    /**
+     * The moment.
+     */
+    at: string;
+    /**
+     * The experiment the viewer is in.
+     */
+    experiment_id?: string;
+    /**
+     * The paywall shown.
+     */
+    paywall_id?: string;
+    /**
+     * The rule that decided.
+     */
+    rule_id?: string;
+    /**
+     * experiment (the one running for the whole placement), rule, default, or none (nothing: the app draws its own).
+     */
+    source: "experiment" | "rule" | "default" | "none";
+    steps: RuleStep[];
+    /**
+     * The viewer's variant.
+     */
+    variant?: string;
+};
 /**
  * The paywall a placement shows.
  */
@@ -2272,6 +3216,60 @@ export type PlacementRequest = {
      */
     paywall_id: string;
 };
+/**
+ * One of a placement's rules: when all its conditions hold for a viewer — none holds for everyone —, it shows its target.
+ */
+export type PlacementRule = {
+    /**
+     * At most 10, all of which must hold.
+     */
+    conditions?: RuleCondition[];
+    /**
+     * When it stops being in effect (UTC).
+     */
+    ends_at?: string;
+    /**
+     * The rule's id: kept across edits, named by the answers and the exposures. None for a new rule; one is given.
+     */
+    id?: string;
+    /**
+     * Its name (1 to 100 characters).
+     */
+    name: string;
+    /**
+     * When a scheduled rule starts being in effect (UTC).
+     */
+    starts_at?: string;
+    /**
+     * live: in effect now (until ends_at); scheduled: in effect from starts_at (until ends_at); inactive: not in effect.
+     */
+    state: "live" | "scheduled" | "inactive";
+    /**
+     * What it is now (answers say it; a request's is not read): in_effect, pending (scheduled, not started), ended, inactive.
+     */
+    status?: "in_effect" | "pending" | "ended" | "inactive";
+    target: RuleTarget;
+};
+/**
+ * A placement's rules, in the order they are read: the first in effect that holds for a viewer wins.
+ */
+export type PlacementRules = {
+    /**
+     * The placement.
+     */
+    placement: string;
+    /**
+     * Their revision, also their ETag: send it back as If-Match.
+     */
+    revision: number;
+    rules: PlacementRule[];
+};
+/**
+ * A placement's rules, all of them, in the order they are to be read (at most 50).
+ */
+export type PlacementRulesRequest = {
+    rules: PlacementRule[];
+};
 /**
  * The project's placements (at most 200), by key.
  */
@@ -2362,6 +3360,75 @@ export type PortalSession = {
      */
     url: string;
 };
+/**
+ * A viewer to try: what its app would send, and who it is. user_id's entitlements and first seen are read from the project, unless entitlements and first_seen_days are given; user_id, else installation_id, is the subject an experiment's variant is drawn for.
+ */
+export type PreviewContext = {
+    /**
+     * The registered app (X-Palbase-App).
+     */
+    app?: string;
+    /**
+     * The app's version (X-Palbase-Client-Version).
+     */
+    app_version?: string;
+    /**
+     * What the app says of the viewer (X-Palbase-Attributes): at most 20 keys, 2 KiB, strings, numbers, booleans.
+     */
+    attributes?: {
+        [key: string]: unknown;
+    };
+    /**
+     * The country (X-Palbase-Storefront, else the address's): ISO 3166-1 alpha-2 or alpha-3.
+     */
+    country?: string;
+    /**
+     * The viewer's active entitlements, instead of user_id's.
+     */
+    entitlements?: string[];
+    /**
+     * Whole days since the viewer was first seen, instead of user_id's.
+     */
+    first_seen_days?: number;
+    /**
+     * The installation (X-Palbase-Installation).
+     */
+    installation_id?: string;
+    /**
+     * The locale, a BCP 47 tag (Accept-Language).
+     */
+    locale?: string;
+    /**
+     * ios, android or web (X-Platform).
+     */
+    platform?: string;
+    /**
+     * The SDK's name (X-Palbase-SDK's), with sdk_version.
+     */
+    sdk?: string;
+    /**
+     * The SDK's version, with sdk.
+     */
+    sdk_version?: string;
+    /**
+     * The signed-in user.
+     */
+    user_id?: string;
+};
+/**
+ * What to try: a viewer, a moment (now when none), and the rules being edited (the saved ones when none).
+ */
+export type PreviewRequest = {
+    /**
+     * The moment (UTC): a scheduled rule's start, an end.
+     */
+    at?: string;
+    context: PreviewContext;
+    /**
+     * Rules not yet saved, to try instead of the placement's.
+     */
+    rules?: PlacementRule[];
+};
 /**
  * The one price entered: each store prices the other currencies its own way (Apple's price points, Google's conversion, Stripe's), except those set by hand.
  */
@@ -2696,6 +3763,159 @@ export type Revenue = {
      */
     currency: string;
 };
+/**
+ * One thing a rule asks of a viewer. `field` is what it reads, `op` how:
+ * - `country` (`in`, `not_in`; `values` ISO 3166-1 alpha-2, alpha-3 read as alpha-2): the store's country the app sends (X-Palbase-Storefront), else the country of the request's address.
+ * - `platform` (`in`, `not_in`; `values` ios, android, web): X-Platform, else `?channel=`.
+ * - `app` (`in`, `not_in`; `values` registered apps' ids): X-Palbase-App.
+ * - `app_version` (`eq`, `neq`, `gt`, `gte`, `lt`, `lte`; `value` a version string): X-Palbase-Client-Version, compared as Semantic Versioning orders versions (2.1 is 2.1.0; a pre-release before its release).
+ * - `sdk_version` (the same operators; `sdk` the SDK's name, `value` a version): X-Palbase-SDK — a viewer on another SDK does not meet it.
+ * - `locale` (`in`, `not_in`; `values` BCP 47 tags): the first tag of Accept-Language; tr covers tr-TR, en-GB covers en-GB alone.
+ * - `entitlement` (`has`: any of `values`; `lacks`: none of them; the catalog's entitlement keys): the server's — the signed-in user's active entitlements; a viewer without a customer has none.
+ * - `first_seen_days` (`gt`, `gte`, `lt`, `lte`; `value` whole days, 0 to 3650): the server's — whole days since the user was first seen here.
+ * - `attribute` (`key`; `in`, `not_in` with `values`, `exists`, `not_exists`, `gt`, `gte`, `lt`, `lte` with a number `value`): X-Palbase-Attributes, what the app says of the viewer — targeting only.
+ * A value the request does not carry meets no condition on it, `not_in` neither (`not_exists` aside).
+ * Targeting picks what to show; it is not access control: the storefront, the attributes and the versions are what the client says of itself — no price or region entitlement may hang on them.
+ */
+export type RuleCondition = {
+    /**
+     * What it reads.
+     */
+    field: "country" | "platform" | "app" | "app_version" | "sdk_version" | "locale" | "entitlement" | "first_seen_days" | "attribute";
+    /**
+     * The attribute's key (an attribute condition's alone).
+     */
+    key?: string;
+    /**
+     * How.
+     */
+    op: "in" | "not_in" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "has" | "lacks" | "exists" | "not_exists";
+    /**
+     * The SDK the version is of, as X-Palbase-SDK names it (an sdk_version condition's alone).
+     */
+    sdk?: string;
+    /**
+     * An order's operand: a version (app_version, sdk_version), a number (first_seen_days, an attribute).
+     */
+    value?: RuleVersion | RuleNumber;
+    /**
+     * A set's members (1 to 50), or the entitlements of has and lacks.
+     */
+    values?: string[];
+};
+/**
+ * What one condition came to.
+ */
+export type RuleConditionResult = {
+    /**
+     * What it reads.
+     */
+    field: string;
+    /**
+     * Its place in the rule's conditions.
+     */
+    index: number;
+    /**
+     * Whether it holds.
+     */
+    met: boolean;
+    /**
+     * The viewer carries no value for it (so it does not hold).
+     */
+    unknown?: boolean;
+};
+/**
+ * A number, as first_seen_days (whole days) and an attribute's order compare it.
+ */
+export type RuleNumber = number;
+/**
+ * One thing wrong with a placement's rules.
+ */
+export type RuleProblem = {
+    /**
+     * What it is (invalid_rule_name, invalid_state, invalid_schedule, invalid_target, unknown_field, invalid_op, invalid_value, invalid_values, too_many_rules, too_many_conditions, duplicate_rule_id, unknown_paywall, unpublished_paywall, experiment_not_targetable …).
+     */
+    code: string;
+    /**
+     * What to do about it.
+     */
+    message: string;
+    /**
+     * Where it is (rules[1].conditions[0].values[2]).
+     */
+    path: string;
+};
+/**
+ * What one rule came to for the viewer.
+ */
+export type RuleStep = {
+    /**
+     * Each condition's, when the rule was in effect and its target could be shown.
+     */
+    conditions?: RuleConditionResult[];
+    /**
+     * The rule's name.
+     */
+    name: string;
+    /**
+     * matched (it decided); unmet (not in effect, or a condition does not hold); unavailable (its experiment no longer runs); not_reached (decided before it).
+     */
+    outcome: "matched" | "unmet" | "unavailable" | "not_reached";
+    /**
+     * The rule.
+     */
+    rule_id: string;
+    /**
+     * What it is at the moment: in_effect, pending, ended, inactive.
+     */
+    status: "in_effect" | "pending" | "ended" | "inactive";
+};
+/**
+ * What a rule shows: a published paywall, or the variant of the experiment running on the placement for the rules (audience `rules`). Exactly one.
+ */
+export type RuleTarget = {
+    /**
+     * The experiment: the viewer gets its variant, the same every time.
+     */
+    experiment_id?: string;
+    /**
+     * The paywall: published.
+     */
+    paywall_id?: string;
+};
+/**
+ * A version, as app_version and sdk_version compare it: one to four numbers, a pre-release after - (2.1.0, 2.1, 3.0.0-beta.1).
+ */
+export type RuleVersion = string;
+/**
+ * The error envelope of refused rules, with every problem when they break a rule (`invalid_rules`).
+ */
+export type RulesError = {
+    /**
+     * Machine-readable error code (snake_case)
+     */
+    error: string;
+    /**
+     * Human-readable explanation
+     */
+    error_description: string;
+    /**
+     * Every problem, by path: with `invalid_rules`, absent otherwise.
+     */
+    problems?: RuleProblem[];
+    /**
+     * 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;
+};
 /**
  * The error envelope of a refused save, with every problem when the catalog breaks a rule (`invalid_catalog`).
  */
@@ -3172,9 +4392,13 @@ export type VariantResult = {
     weight: number;
 };
 /**
- * The variant that won.
+ * The variant that won, and how it is rolled out.
  */
 export type WinnerRequest = {
+    /**
+     * For an experiment for everyone at the placement: roll the winner out as a live rule at the top of the placement's rules (for everyone, to narrow later) and keep the placement's default; otherwise the winner becomes the default.
+     */
+    as_rule?: boolean;
     /**
      * The variant's key.
      */
@@ -3723,7 +4947,7 @@ export declare function client(t: Transport): {
     /**
      * 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`).
+     * Starts an experiment on a placement: from then on the placement shows each subject in its audience — 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`). An experiment for the rules (audience `rules`) shows the viewers the placement's rules targeting it send it — the placement is one already (404 `placement_not_found`); one for everyone (audience `placement`, when none is named) is decided before the placement's rules, and the placement keeps its default for when it ends.
      */
     startExperiment(input: {
         headers?: {
@@ -3761,7 +4985,7 @@ export declare function client(t: Transport): {
     /**
      * Stop an experiment
      *
-     * Stops a running experiment: the placement shows its first variant's paywall to everyone. Its results stay.
+     * Stops a running experiment, at once: what it showed becomes its first variant's paywall — the placement's default for an experiment for everyone there, the rules' target for one for the rules. Its results stay.
      */
     stopExperiment(input: {
         path: {
@@ -3775,7 +4999,7 @@ export declare function client(t: Transport): {
     /**
      * 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.
+     * Ends a running experiment with a winner, at once: for everyone at the placement, the winner's paywall becomes the placement's default — or, with `as_rule`, a live rule at the top of its rules shows it to everyone (to narrow later) and the default stays; for the rules, the rules that targeted the experiment show the winner's paywall. Its results stay.
      */
     declareExperimentWinner(input: {
         path: {
@@ -3843,6 +5067,40 @@ export declare function client(t: Transport): {
         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>>;
+    /**
+     * List the paywall assets
+     *
+     * The project's paywall assets, newest first.
+     */
+    listPaywallAssets(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PaywallAssets>>;
+    /**
+     * Register a paywall asset
+     *
+     * Registers an object of the project's public bucket paywall-assets for its paywalls: Studio and the CLI upload it with the project's storage first (and make the bucket when it is missing), then register its path here. The module builds the object's address itself, from the project's own storage — never from an address it is given — and reads it there as every app will, saying what it is by its bytes, never by its name or the type it was stored with: an image (png, jpeg or webp, at most 2 MiB; never svg), a video (mp4 or mov, 50 MiB), a font (ttf, otf or woff2, 5 MiB), or an HTML block's zip (5 MiB; at most 200 files and 20 MiB opened, read to the end; index.html at its root; no file leaving the root, no link). It stops reading past the bound. It keeps the asset's SHA-256 and size: an app draws what it downloads only when it is that, and a paywall naming an asset whose object was since changed or removed is warned of in a draft and refused when published. A project has at most 500 assets.
+     */
+    registerPaywallAsset(input: {
+        headers?: {
+            "Idempotency-Key"?: string;
+        };
+        body: PaywallAssetRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, PaywallAsset>>;
+    /**
+     * Delete a paywall asset
+     *
+     * Forgets an asset no paywall names — in a draft, or in any version kept (409 `asset_in_use`). The object stays in the project's storage.
+     */
+    deletePaywallAsset(input: {
+        path: {
+            asset_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>>;
     /**
      * Check a paywall
      *
@@ -3899,7 +5157,7 @@ export declare function client(t: Transport): {
     /**
      * 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`.
+     * 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`. Every asset the draft names is looked at in the project's storage: one no longer there (`asset_missing`) or no longer the bytes registered (`asset_changed`) refuses the publish.
      */
     publishPaywall(input: {
         path: {
@@ -3941,7 +5199,7 @@ export declare function client(t: Transport): {
     /**
      * List the placements
      *
-     * The project's placements, by key: the paywall each shows, or the experiment running on it.
+     * The project's placements, by key: the default paywall each shows, the experiment running on it for everyone, how many rules it has.
      */
     listPlacements(input?: {
         signal?: AbortSignal;
@@ -3949,7 +5207,7 @@ export declare function client(t: Transport): {
     /**
      * 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`).
+     * Gives a placement its default paywall, making the placement when it is new: what it shows whoever none of its rules holds for. 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 for everyone at the placement, the experiment decides, and its end the default (409 `experiment_running`). A project has at most 200 placements (409 `too_many_placements`).
      */
     setPlacement(input: {
         path: {
@@ -3964,7 +5222,7 @@ export declare function client(t: Transport): {
     /**
      * 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`).
+     * Forgets a placement and its rules: 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: {
@@ -3978,7 +5236,7 @@ export declare function client(t: Transport): {
     /**
      * 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.
+     * 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). `variant` and `rule_id` are what the answer named — claims, checked against the placement as it is: the rule is written when it is one of the placement's and shows the paywall reported (or sends to the experiment of the variant counted); the variant counts when its experiment runs for the whole placement, or the rule reported sends to it, and it is the subject's own variant there. A claim that does not hold leaves the exposure to the paywall alone — none is refused: what was shown before the viewer bought, before a schedule turned, before the rules were edited still counts. 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: {
@@ -3993,7 +5251,7 @@ export declare function client(t: Transport): {
     /**
      * 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.
+     * What an app draws at a placement. Who sees what: an experiment running for the whole placement decides first — 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 —; then the placement's rules, in order: the first in effect whose conditions all hold shows its paywall, or its experiment's variant; then the placement's default. The rules read what the app declares — X-Platform, X-Palbase-App, X-Palbase-Client-Version, X-Palbase-SDK, X-Palbase-Storefront, Accept-Language, X-Palbase-Attributes — and what the server knows: the user's entitlements, the days since the user was first seen, the request's address's country when no storefront is named. `source` and `rule_id` say which decided. Targeting picks what to show; it is not access control: the storefront, the attributes and the versions are what the client says of itself — no price or region entitlement may hang on them. The app says the newest paywall schema its SDK draws (X-Palbase-Paywall-Schema; this server's, 2, when absent) and is given the newest version of that 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 a newer schema — the answer is 204 and the app draws its own (from the offerings). An SDK that draws no schema this server takes (under 2) is told to update: 426 `paywall_schema_too_old`, and it draws its own. `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: {
@@ -4005,10 +5263,59 @@ export declare function client(t: Transport): {
         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;
+            "If-None-Match"?: string; /** The app's platform: ios, android or web (a placement's platform rules read it; `?channel=` when absent). */
+            "X-Platform"?: string; /** The app's version, as its users see it (CFBundleShortVersionString, versionName): app_version rules read it. */
+            "X-Palbase-Client-Version"?: string; /** The registered app's id: app rules read it. */
+            "X-Palbase-App"?: string; /** The SDK's name and version, name/version (palbase-swift/1.4.0): sdk_version rules read it. */
+            "X-Palbase-SDK"?: string; /** The store's country — StoreKit's Storefront.countryCode, Play's billing country —, ISO 3166-1 alpha-2 or alpha-3: country rules read it, the request's address's country when absent. */
+            "X-Palbase-Storefront"?: string; /** What the app says of the viewer, for attribute rules (targeting only): a JSON object of at most 20 keys (a letter, then letters, digits and _ . -, at most 40), values strings (at most 256), numbers or booleans; at most 2 KiB, non-ASCII escaped (\uXXXX). */
+            "X-Palbase-Attributes"?: string; /** The app's languages: locale rules read the first. */
+            "Accept-Language"?: 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>>;
+    /**
+     * Preview what a placement shows a viewer
+     *
+     * What the placement shows a viewer, and why: the experiment running for the whole placement, the rule that decided, or the default — with what every rule came to, condition by condition. The console's live preview: by the saved rules, or by rules being edited (`rules`), at a moment (`at`). Nothing is counted or changed.
+     */
+    previewPlacement(input: {
+        path: {
+            placement: string;
+        };
+        headers?: {
+            "Idempotency-Key"?: string;
+        };
+        body: PreviewRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PlacementPreview>>;
+    /**
+     * Read a placement's rules
+     *
+     * A placement's rules, in the order they are read, each with what it is now (status). The ETag is their revision.
+     */
+    getPlacementRules(input: {
+        path: {
+            placement: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PlacementRules>>;
+    /**
+     * Replace a placement's rules
+     *
+     * Replaces a placement's rules, all of them, in the order they are to be read: the first in effect whose conditions all hold for a viewer shows its target — a published paywall, or the variant of the experiment running on the placement for the rules —, after an experiment running for the whole placement and before the placement's default. At most 50 rules of at most 10 conditions. If-Match names the revision they were edited from: of two people editing at once, the second is told (412 `rules_changed`), not overwritten. Targeting picks what to show; it is not access control: the storefront, the attributes and the versions are what the client says of itself — no price or region entitlement may hang on them.
+     */
+    setPlacementRules(input: {
+        path: {
+            placement: 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: PlacementRulesRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PlacementRules>>;
     /**
      * Read the settings
      *