palbase 0.1.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.
  */
@@ -1087,6 +1129,165 @@ 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 = {
+    /**
+     * placement: everyone at the placement, decided before its rules; rules: the viewers the rules targeting it send it.
+     */
+    audience: "placement" | "rules";
+    /**
+     * 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 (what it showed becomes 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 = {
+    /**
+     * 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 (for everyone there, 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;
+    confidence: Confidence;
+    /**
+     * Whether declaring the leader the winner is sound: confidence has no reason left.
+     */
+    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. variant and rule_id are claims, checked against the placement: one that does not hold is not written.
+ */
+export type ExposureRequest = {
+    /**
+     * The paywall.
+     */
+    paywall_id: string;
+    /**
+     * The rule the answer named, when it named one.
+     */
+    rule_id?: string;
+    /**
+     * The variant the answer named, when it named one.
+     */
+    variant?: string;
+    /**
+     * Its version.
+     */
+    version: number;
+};
 /**
  * A granted (promotional) entitlement.
  */
@@ -1450,213 +1651,1911 @@ export type OwnershipTransferredEvent = {
     via: "restore";
 };
 /**
- * How a product is paid for.
+ * A paywall as Studio edits it: its draft, and what was published of it.
  */
-export type Plan = {
-    /**
-     * A non-renewing product's duration, an ISO 8601 duration such as P1M.
-     */
-    duration?: string;
-    intro?: IntroOffer;
+export type Paywall = {
     /**
-     * Its key: lowercase letters, digits and _, starting with a letter.
+     * When it was made.
      */
-    key: string;
+    created_at: string;
     /**
-     * A subscription's billing period, an ISO 8601 duration: the App Store sells by P1W, P1M, P2M, P3M, P6M, P1Y; Google Play adds P4W, P4M, P8M; Stripe bills at most once a year.
+     * Who made it (the key).
      */
-    period?: string;
-    price: Price;
-};
-/**
- * A confirmation, with the hash of the plan shown.
- */
-export type PlanConfirmation = {
+    created_by: string;
+    draft: PaywallDefinition;
     /**
-     * The Stripe part's hash; with no Stripe account connected, the App Store part's.
+     * Rises with every save of the draft; If-Match names it.
      */
-    hash: string;
-};
-/**
- * One write a store will get to come to the catalog.
- */
-export type PlanStep = {
+    draft_revision: number;
     /**
-     * What it writes, as the store names it.
+     * The paywall's id.
      */
-    fields?: {
-        [key: string]: unknown;
-    };
+    id: string;
     /**
-     * Whether it makes something the store never lets go of: a product id at Apple or Google stays taken even once deleted.
+     * Its name (the draft's).
      */
-    irreversible: boolean;
+    name: string;
     /**
-     * What the person should know of it: how a price is resolved, why it waits.
+     * 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.
      */
-    note?: string;
+    problems: PaywallProblem[];
     /**
-     * What it does: create_product, update_product, create_price (Stripe); create_subscription_group, create_subscription, create_in_app_purchase (the App Store); create_subscription, create_onetime_product (Google Play).
+     * When the newest version was published.
      */
-    op: string;
+    published_at?: string;
     /**
-     * The catalog's plan.
+     * The newest version published; 0 before the first.
      */
-    plan?: string;
+    published_version: number;
     /**
-     * The catalog's product.
+     * When the draft was last saved.
      */
-    product: string;
+    updated_at: string;
     /**
-     * The store's id of what it writes.
+     * Who saved it last.
      */
-    store_id?: string;
+    updated_by: string;
 };
 /**
- * Where Stripe's portal sends the customer back.
+ * What a button does.
  */
-export type PortalRequest = {
+export type PaywallAction = {
     /**
-     * A registered web app's origin, or a native app's own scheme.
+     * Package.
      */
-    return_url: string;
-};
-/**
- * Stripe's customer portal, opened for the customer.
- */
-export type PortalSession = {
+    package?: string;
     /**
-     * Where to send the customer.
+     * Sheet.
      */
-    url: string;
+    sheet?: string;
+    /**
+     * Type.
+     */
+    type: "close" | "restore" | "open_url" | "terms" | "privacy" | "offer_code" | "sheet" | "select_package";
+    /**
+     * Url.
+     */
+    url?: string;
 };
 /**
- * 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.
+ * How the component appears; a renderer skips it when the system asks to reduce motion.
  */
-export type Price = {
+export type PaywallAnimation = {
     /**
-     * The amount in the currency's minor units (999 is 9.99).
+     * Delay ms.
      */
-    amount: number;
+    delay_ms?: number;
     /**
-     * Its ISO 4217 currency (USD).
+     * Duration ms.
      */
-    currency: string;
+    duration_ms?: number;
     /**
-     * Amounts set by hand in other currencies, in their minor units.
+     * Easing.
      */
-    overrides?: {
-        [key: string]: number;
-    };
+    easing?: "ease_out" | "ease_in_out" | "spring";
+    /**
+     * Type.
+     */
+    type: "fade" | "slide_up" | "slide_down" | "slide_leading" | "slide_trailing" | "scale";
 };
 /**
- * One thing sold, on every channel it names.
+ * 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 Product = {
+export type PaywallAsset = {
     /**
-     * Where it is sold — ios (the App Store), android (Google Play), web (Stripe) — each with what is its own there; {} when it is sold there as it is.
+     * The project's bucket it is in: paywall-assets.
      */
-    channels: {
-        [key: string]: Channel;
-    };
-    credits?: ProductCredits;
+    bucket: string;
     /**
-     * The entitlements it gives (a consumable gives none).
+     * Its size.
      */
-    entitlements?: string[];
+    bytes: number;
     /**
-     * A subscription's group: the subscriptions a customer can move between (Apple's subscription group, the plans a Stripe customer can switch to). The App Store sells every subscription in one.
+     * Its content type, from its bytes.
      */
-    group?: string;
+    content_type: string;
     /**
-     * Its key: lowercase letters, digits and _, starting with a letter, at most 40. The stores know a plan of it as <product>.<plan> (40 characters at most).
+     * When it was registered.
      */
-    key: string;
+    created_at: string;
     /**
-     * Its text by language: the base locale's at least.
+     * Who registered it (the key).
      */
-    locales: {
-        [key: string]: Locale;
-    };
+    created_by: string;
     /**
-     * How it is paid for: a subscription's periods and prices; one price for anything else.
+     * An HTML block's files.
      */
-    plans: Plan[];
+    files?: number;
     /**
-     * How much of each limit it gives.
+     * The asset's id.
      */
-    quota?: QuotaAllowance[];
+    id: string;
     /**
-     * A subscription's level in its group, 1 or more: higher is more.
+     * What its bytes are: an image (png, jpeg, webp), a video (mp4, mov), a font (ttf, otf, woff2), or an HTML block's zip.
      */
-    tier?: number;
+    kind: "image" | "video" | "font" | "html";
     /**
-     * Its kind: subscription (renews until canceled), non_consumable (bought once, kept), consumable (bought again and again: credits), non_renewing (a period bought once).
+     * What an HTML block's files hold together.
      */
-    type: string;
-};
-/**
- * The credits a product gives: per purchase for a consumable, per period for a subscription.
- */
-export type ProductCredits = {
+    opened_bytes?: number;
     /**
-     * How many.
+     * Its path in the bucket.
      */
-    amount: number;
+    path: string;
     /**
-     * The credit (a key of the catalog's credits).
+     * How a definition names it: asset:<id>.
      */
-    currency: string;
+    ref: string;
     /**
-     * A subscription's: none (a period's credits end with the period) or all (they stay). Credits bought never end.
+     * The SHA-256 of its bytes, hex: an app draws what it downloads only when it is this.
      */
-    rollover?: string;
+    sha256: string;
+    /**
+     * Its public https address.
+     */
+    url: string;
 };
 /**
- * purchases.purchase.completed: a purchase new to the ledger: a subscription's start or a one-time product, in any store.
+ * An asset a definition names, as an app downloads it before it shows the paywall.
  */
-export type PurchaseCompletedEvent = {
-    /**
-     * The purchase's id in the ledger.
-     */
-    chain_id: string;
+export type PaywallAssetRef = {
     /**
-     * The customer.
+     * Its size.
      */
-    customer_id: string;
+    bytes: number;
     /**
-     * Whether it is a store's test purchase.
+     * The asset: a definition names it asset:<id>.
      */
-    is_sandbox: boolean;
+    id: string;
     /**
-     * Its plan; empty when unmapped.
+     * What it is.
      */
-    plan: string;
+    kind: "image" | "video" | "font" | "html";
     /**
-     * The catalog's product; empty when unmapped.
+     * The SHA-256 its bytes must have: an asset whose download is not this is not drawn.
      */
-    product: string;
+    sha256: string;
     /**
-     * Where it was bought.
+     * Its https address.
      */
-    store: "app_store" | "play_store" | "stripe";
+    url: string;
 };
 /**
- * A one-time purchase the customer owns.
+ * 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 PurchaseInfo = {
+export type PaywallAssetRequest = {
     /**
-     * Its id in the ledger.
+     * What the object is meant to be: a registration whose bytes are another kind is refused (asset_kind_mismatch).
      */
-    id: string;
+    kind?: "image" | "video" | "font" | "html";
     /**
-     * Whether it is a store's test purchase.
+     * 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.
      */
-    is_sandbox: boolean;
+    path: string;
+};
+/**
+ * The project's paywall assets (at most 500), newest first.
+ */
+export type PaywallAssets = {
     /**
-     * The catalog's product; absent when the catalog does not map what the store sold.
+     * The assets.
      */
-    product?: string;
+    assets: PaywallAsset[];
+};
+/**
+ * A border.
+ */
+export type PaywallBorder = {
+    /**
+     * Color.
+     */
+    color: string;
+    /**
+     * Width.
+     */
+    width: number;
+};
+/**
+ * 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 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;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * The component.
+     */
+    type: "button";
+    visible?: PaywallCondition;
+};
+/**
+ * Pages the customer swipes through, the next peeking in, advancing on their own, with an indicator.
+ */
+export type PaywallCarousel = {
+    animation?: PaywallAnimation;
+    /**
+     * Auto advance ms.
+     */
+    auto_advance_ms?: number;
+    /**
+     * 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;
+    indicator?: PaywallIndicator;
+    /**
+     * Loop.
+     */
+    loop?: boolean;
+    /**
+     * Pages.
+     */
+    pages: PaywallComponent[];
+    /**
+     * Peek.
+     */
+    peek?: number;
+    /**
+     * Spacing.
+     */
+    spacing?: number;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * The component.
+     */
+    type: "carousel";
+    visible?: PaywallCondition;
+};
+/**
+ * A color: a token of the theme's colors (the light or the dark value, as the app appears), or #RRGGBB / #RRGGBBAA.
+ */
+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 = {
+    /**
+     * Appearance.
+     */
+    appearance?: "light" | "dark";
+    /**
+     * Intro eligible.
+     */
+    intro_eligible?: boolean;
+    /**
+     * Locale.
+     */
+    locale?: string[];
+    /**
+     * Platform.
+     */
+    platform?: ("ios" | "android" | "web")[];
+    /**
+     * Selected package.
+     */
+    selected_package?: string[];
+    /**
+     * Tab.
+     */
+    tab?: string;
+};
+/**
+ * Each corner its own, in points or a token of the theme's radii.
+ */
+export type PaywallCorners = {
+    /**
+     * Bottom leading.
+     */
+    bottom_leading?: PaywallPoints | PaywallToken;
+    /**
+     * Bottom trailing.
+     */
+    bottom_trailing?: PaywallPoints | PaywallToken;
+    /**
+     * Top leading.
+     */
+    top_leading?: PaywallPoints | PaywallToken;
+    /**
+     * Top trailing.
+     */
+    top_trailing?: PaywallPoints | PaywallToken;
+};
+/**
+ * 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 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;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    target: PaywallTarget;
+    /**
+     * The component.
+     */
+    type: "countdown";
+    visible?: PaywallCondition;
+};
+/**
+ * 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 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;
+    /**
+     * Src.
+     */
+    src: string;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * The component.
+     */
+    type: "custom_html";
+    visible?: PaywallCondition;
+};
+/**
+ * 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 PaywallDefinition = {
+    /**
+     * The language a text falls back to: a tag such as en or pt-BR.
+     */
+    default_locale: string;
+    footer?: PaywallComponent;
+    header?: PaywallComponent;
+    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: 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).
+     */
+    schema: number;
+    sheets?: PaywallSheets;
+    theme: PaywallTheme;
+};
+/**
+ * A thin line across its stack.
+ */
+export type PaywallDivider = {
+    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;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * Thickness.
+     */
+    thickness?: number;
+    /**
+     * The component.
+     */
+    type: "divider";
+    visible?: PaywallCondition;
+};
+/**
+ * Each edge its own, in points or a token of the theme's spacing.
+ */
+export type PaywallEdges = {
+    /**
+     * Bottom.
+     */
+    bottom?: PaywallPoints | PaywallToken;
+    /**
+     * Leading.
+     */
+    leading?: PaywallPoints | PaywallToken;
+    /**
+     * Top.
+     */
+    top?: PaywallPoints | PaywallToken;
+    /**
+     * Trailing.
+     */
+    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.
+ */
+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 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 = {
+    /**
+     * Align.
+     */
+    align?: "start" | "center" | "end";
+    animation?: PaywallAnimation;
+    /**
+     * Color.
+     */
+    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;
+    /**
+     * Letter spacing.
+     */
+    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";
+    /**
+     * Uppercase.
+     */
+    uppercase?: boolean;
+    visible?: PaywallCondition;
+    /**
+     * Weight.
+     */
+    weight?: 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
+};
+/**
+ * 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 design system: colors for light and dark, a type scale, radii and spacing; the components name them.
+ */
+export type PaywallTheme = {
+    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;
+    /**
+     * 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: 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.
+ */
+export type PaywallValidation = {
+    /**
+     * The warnings, by path.
+     */
+    problems: PaywallProblem[];
+};
+/**
+ * A published version of a paywall.
+ */
+export type PaywallVersion = {
+    definition?: PaywallDefinition;
+    /**
+     * The paywall.
+     */
+    paywall_id: string;
+    /**
+     * When it was published.
+     */
+    published_at: string;
+    /**
+     * Who published it (the key).
+     */
+    published_by: string;
+    /**
+     * 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.
+     */
+    src: string;
+    states?: PaywallStates;
+    style?: PaywallStyle;
+    /**
+     * The component.
+     */
+    type: "video";
+    visible?: PaywallCondition;
+};
+/**
+ * A muted video behind the component.
+ */
+export type PaywallVideoFill = {
+    /**
+     * Loop.
+     */
+    loop?: boolean;
+    /**
+     * Poster.
+     */
+    poster?: string;
+    /**
+     * Src.
+     */
+    src: string;
+    /**
+     * Type.
+     */
+    type: "video";
+};
+/**
+ * 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 for everyone there (audience placement).
+     */
+    experiment_id?: string;
+    /**
+     * The placement's key.
+     */
+    key: string;
+    /**
+     * 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.
+     */
+    updated_at: string;
+    /**
+     * Who did (the key).
+     */
+    updated_by: string;
+};
+/**
+ * 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;
+    /**
+     * The paywall.
+     */
+    paywall_id: string;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Its version; report it with the exposure.
+     */
+    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.
+ */
+export type PlacementRequest = {
+    /**
+     * The paywall.
+     */
+    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.
+ */
+export type Placements = {
+    /**
+     * The placements.
+     */
+    placements: Placement[];
+};
+/**
+ * How a product is paid for.
+ */
+export type Plan = {
+    /**
+     * A non-renewing product's duration, an ISO 8601 duration such as P1M.
+     */
+    duration?: string;
+    intro?: IntroOffer;
+    /**
+     * Its key: lowercase letters, digits and _, starting with a letter.
+     */
+    key: string;
+    /**
+     * A subscription's billing period, an ISO 8601 duration: the App Store sells by P1W, P1M, P2M, P3M, P6M, P1Y; Google Play adds P4W, P4M, P8M; Stripe bills at most once a year.
+     */
+    period?: string;
+    price: Price;
+};
+/**
+ * A confirmation, with the hash of the plan shown.
+ */
+export type PlanConfirmation = {
+    /**
+     * The Stripe part's hash; with no Stripe account connected, the App Store part's.
+     */
+    hash: string;
+};
+/**
+ * One write a store will get to come to the catalog.
+ */
+export type PlanStep = {
+    /**
+     * What it writes, as the store names it.
+     */
+    fields?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Whether it makes something the store never lets go of: a product id at Apple or Google stays taken even once deleted.
+     */
+    irreversible: boolean;
+    /**
+     * What the person should know of it: how a price is resolved, why it waits.
+     */
+    note?: string;
+    /**
+     * What it does: create_product, update_product, create_price (Stripe); create_subscription_group, create_subscription, create_in_app_purchase (the App Store); create_subscription, create_onetime_product (Google Play).
+     */
+    op: string;
+    /**
+     * The catalog's plan.
+     */
+    plan?: string;
+    /**
+     * The catalog's product.
+     */
+    product: string;
+    /**
+     * The store's id of what it writes.
+     */
+    store_id?: string;
+};
+/**
+ * Where Stripe's portal sends the customer back.
+ */
+export type PortalRequest = {
+    /**
+     * A registered web app's origin, or a native app's own scheme.
+     */
+    return_url: string;
+};
+/**
+ * Stripe's customer portal, opened for the customer.
+ */
+export type PortalSession = {
+    /**
+     * Where to send the customer.
+     */
+    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.
+ */
+export type Price = {
+    /**
+     * The amount in the currency's minor units (999 is 9.99).
+     */
+    amount: number;
+    /**
+     * Its ISO 4217 currency (USD).
+     */
+    currency: string;
+    /**
+     * Amounts set by hand in other currencies, in their minor units.
+     */
+    overrides?: {
+        [key: string]: number;
+    };
+};
+/**
+ * One thing sold, on every channel it names.
+ */
+export type Product = {
+    /**
+     * Where it is sold — ios (the App Store), android (Google Play), web (Stripe) — each with what is its own there; {} when it is sold there as it is.
+     */
+    channels: {
+        [key: string]: Channel;
+    };
+    credits?: ProductCredits;
+    /**
+     * The entitlements it gives (a consumable gives none).
+     */
+    entitlements?: string[];
+    /**
+     * A subscription's group: the subscriptions a customer can move between (Apple's subscription group, the plans a Stripe customer can switch to). The App Store sells every subscription in one.
+     */
+    group?: string;
+    /**
+     * Its key: lowercase letters, digits and _, starting with a letter, at most 40. The stores know a plan of it as <product>.<plan> (40 characters at most).
+     */
+    key: string;
+    /**
+     * Its text by language: the base locale's at least.
+     */
+    locales: {
+        [key: string]: Locale;
+    };
+    /**
+     * How it is paid for: a subscription's periods and prices; one price for anything else.
+     */
+    plans: Plan[];
+    /**
+     * How much of each limit it gives.
+     */
+    quota?: QuotaAllowance[];
+    /**
+     * A subscription's level in its group, 1 or more: higher is more.
+     */
+    tier?: number;
+    /**
+     * Its kind: subscription (renews until canceled), non_consumable (bought once, kept), consumable (bought again and again: credits), non_renewing (a period bought once).
+     */
+    type: string;
+};
+/**
+ * The credits a product gives: per purchase for a consumable, per period for a subscription.
+ */
+export type ProductCredits = {
+    /**
+     * How many.
+     */
+    amount: number;
+    /**
+     * The credit (a key of the catalog's credits).
+     */
+    currency: string;
+    /**
+     * A subscription's: none (a period's credits end with the period) or all (they stay). Credits bought never end.
+     */
+    rollover?: string;
+};
+/**
+ * purchases.purchase.completed: a purchase new to the ledger: a subscription's start or a one-time product, in any store.
+ */
+export type PurchaseCompletedEvent = {
+    /**
+     * The purchase's id in the ledger.
+     */
+    chain_id: string;
+    /**
+     * The customer.
+     */
+    customer_id: string;
+    /**
+     * Whether it is a store's test purchase.
+     */
+    is_sandbox: boolean;
+    /**
+     * Its plan; empty when unmapped.
+     */
+    plan: string;
+    /**
+     * The catalog's product; empty when unmapped.
+     */
+    product: string;
+    /**
+     * Where it was bought.
+     */
+    store: "app_store" | "play_store" | "stripe";
+};
+/**
+ * A one-time purchase the customer owns.
+ */
+export type PurchaseInfo = {
+    /**
+     * Its id in the ledger.
+     */
+    id: string;
+    /**
+     * Whether it is a store's test purchase.
+     */
+    is_sandbox: boolean;
+    /**
+     * The catalog's product; absent when the catalog does not map what the store sold.
+     */
+    product?: string;
     /**
      * When it was bought.
      */
@@ -1827,29 +3726,195 @@ export type ReadinessCheck = {
  */
 export type RefundChangedEvent = {
     /**
-     * The purchase's id in the ledger.
+     * The purchase's id in the ledger.
+     */
+    chain_id: string;
+    /**
+     * The customer.
+     */
+    customer_id: string;
+    /**
+     * Why.
+     */
+    kind: "refund" | "family" | "chargeback" | "other";
+    /**
+     * The taking back was reversed (a dispute won).
+     */
+    reversed: boolean;
+    /**
+     * How much of the payment was taken back, in thousandths (1000: all of it).
+     */
+    share_milli: number;
+    /**
+     * The payment taken back.
+     */
+    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;
+};
+/**
+ * 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)
      */
-    chain_id: string;
+    error: string;
     /**
-     * The customer.
+     * Human-readable explanation
      */
-    customer_id: string;
+    error_description: string;
     /**
-     * Why.
+     * Every problem, by path: with `invalid_rules`, absent otherwise.
      */
-    kind: "refund" | "family" | "chargeback" | "other";
+    problems?: RuleProblem[];
     /**
-     * The taking back was reversed (a dispute won).
+     * Correlation ID for log/audit lookup
      */
-    reversed: boolean;
+    request_id: string;
     /**
-     * How much of the payment was taken back, in thousandths (1000: all of it).
+     * Seconds to wait before retrying; present on a refusal that ends with time.
      */
-    share_milli: number;
+    retry_after?: number;
     /**
-     * The payment taken back.
+     * HTTP status code (mirrors the response status)
      */
-    transaction_id: string;
+    status: number;
 };
 /**
  * The error envelope of a refused save, with every problem when the catalog breaks a rule (`invalid_catalog`).
@@ -2281,6 +4346,64 @@ 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, 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.
+     */
+    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 +4476,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 +4931,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: 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?: {
+            "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, 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: {
+            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, 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: {
+            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 +5047,275 @@ 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>>;
+    /**
+     * 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
+     *
+     * 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`. 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: {
+            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 default paywall each shows, the experiment running on it for everyone, how many rules it has.
+     */
+    listPlacements(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Placements>>;
+    /**
+     * Give a placement a paywall
+     *
+     * 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: {
+            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 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: {
+            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). `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: {
+            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. 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: {
+            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; /** 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
      *