adapty 0.10.0 → 0.12.0

package/dist/cli/views/analytics/segments.js

@@ -0,0 +1,185 @@
+import { csvLine } from './csv.js';
+/** A number the backend does not have is null, and printing it as 0 would be a lie. */
+export const NO_VALUE = '—';
+export const NO_DATA = 'No data for this period.';
+/** The fields that name a group; every other field of a segment is a number of that group. */
+const IDENTITY = ['key', 'title', 'is_total'];
+/** The segment fields every operation has: the CSV header of an answer without segments. */
+const BASE_COLUMNS = [...IDENTITY, 'value'];
+/** An empty text (the key of a "No Data" group, for example) is shown as `""`, so it never reads as a missing value. */
+export const formatValue = (value) => {
+    if (value === null || value === undefined) {
+        return NO_VALUE;
+    }
+    return value === '' ? '""' : String(value);
+};
+/** Every leaf of a value under its dotted name. An empty list has no leaf; a null object is one null leaf. */
+const leaves = (value, name) => {
+    if (Array.isArray(value)) {
+        return value.flatMap((item, index) => leaves(item, `${name}[${index}]`));
+    }
+    if (typeof value === 'object' && value !== null) {
+        return Object.entries(value).flatMap(([key, item]) => leaves(item, name === '' ? key : `${name}.${key}`));
+    }
+    return [[name, value]];
+};
+/** The fields of an object, leaving out the ones the view shows in another way. */
+const fieldsOf = (value, skip) => leaves(Object.fromEntries(Object.entries(value).filter(([key]) => !skip.includes(key))), '');
+/** The API answers with the total first; the views hold to that whatever the order, and drop nothing. */
+const totalFirst = (segments) => [...segments.filter(segment => segment.is_total), ...segments.filter(segment => !segment.is_total)];
+/** A point is found by its `x`. */
+export const pointId = (point) => String(point.x);
+/**
+ * How the human view names a point: its `x`, and for a funnel step or a retention period also its title, the
+ * number once (`-2 Install`, `1 Paid`, `2 Period`).
+ */
+export const pointLabel = (point) => {
+    const { title } = point;
+    const id = pointId(point);
+    if (typeof title !== 'string') {
+        return id;
+    }
+    return title.startsWith(`${id} `) ? title : `${id} ${title}`;
+};
+/** The same for the CSV, `value` first: the title stays a field, since a step's title can differ between segments. */
+const pointCells = (point) => {
+    const fields = fieldsOf(point, ['x']);
+    return [...fields.filter(([name]) => name === 'value'), ...fields.filter(([name]) => name !== 'value')];
+};
+const without = (value, names) => Object.fromEntries(Object.entries(value).filter(([name]) => !names.includes(name)));
+/**
+ * Every field of the answer besides the segments, under its JSON path: `data.value`, `data.compare.value`,
+ * `meta.query.timezone`, `meta.query.filters.date[0]`, `meta.recommended_period.date_from`. The one source of the
+ * summary in both views.
+ */
+const answerFields = ({ data, meta }) => {
+    const { compare } = data;
+    return leaves({
+        data: {
+            ...without(data, ['compare', 'segments']),
+            // A chart or a conversion always says whether it has a compared period: null is a value too
+            ...(compare === undefined ? {} : { compare: compare === null ? null : without(compare, ['segments']) }),
+        },
+        meta,
+    }, '');
+};
+/**
+ * The summary of the asked period: every field of `data` besides the segments, every field of `meta.query` (the
+ * resolved query: the time zone, the filters, the defaults) and every other field of `meta` (a conversion's
+ * `recommended_period`), named as in their object. Of a compared period: the fields of `data.compare`.
+ */
+export const sectionsOf = (answer) => {
+    const fields = answerFields(answer);
+    const { compare, segments } = answer.data;
+    const main = fields.filter(([name]) => !name.startsWith('data.compare'))
+        .map(([name, value]) => [name.replace(/^(?:data|meta\.query|meta)\./, ''), value]);
+    const compared = fields.filter(([name]) => name.startsWith('data.compare.'))
+        .map(([name, value]) => [name.slice('data.compare.'.length), value]);
+    return [
+        { period: 'main', segments: totalFirst(segments), summary: main },
+        ...(compare === undefined || compare === null ? [] : [{ period: 'compare', segments: totalFirst(compare.segments), summary: compared }]),
+    ];
+};
+export const line = ([name, value]) => `${name}: ${formatValue(value)}`;
+/** Names in first-seen order, without a name that only stands for its nested fields elsewhere (a null `predict`). */
+const columnsOf = (rows) => {
+    const names = [...new Set(rows.flatMap(fields => fields.map(([name]) => name)))];
+    return names.filter(name => !names.some(other => other.startsWith(`${name}.`) || other.startsWith(`${name}[`)));
+};
+/**
+ * The total is the segment with `is_total`; every other group is found by its raw key, so `null`, `""` and `"None"`
+ * are three groups, and none of them is the total. A key can repeat inside one period (a funnel key is the group
+ * title): such a key is the same group in both periods only by position, the first with the first, and so on. A key
+ * that is unique in both periods is matched by itself.
+ */
+const groupsOf = ({ data }) => {
+    const periods = [
+        ['main', totalFirst(data.segments)],
+        ['compare', totalFirst(data.compare?.segments ?? [])],
+    ];
+    const keyOf = (segment) => JSON.stringify(segment.key);
+    const count = (segments, key) => segments
+        .filter(segment => !segment.is_total && keyOf(segment) === key).length;
+    const groups = new Map();
+    for (const [period, segments] of periods) {
+        const seen = new Map();
+        for (const segment of segments) {
+            const key = keyOf(segment);
+            const position = seen.get(key) ?? 0;
+            seen.set(key, position + 1);
+            const unique = periods.every(([, other]) => count(other, key) <= 1);
+            const own = unique ? `key:${key}` : `key:${key}#${position}`;
+            const id = segment.is_total ? 'total' : own;
+            groups.set(id, { ...groups.get(id), [period]: segment });
+        }
+    }
+    const total = groups.get('total');
+    const others = [...groups.entries()].filter(([id]) => id !== 'total').map(([, group]) => group);
+    return [...(total === undefined ? [] : [total]), ...others];
+};
+/** The columns of one period: the numbers of its segments, then each point's `value` and its other fields. */
+const periodColumns = (segments, prefix, pick) => {
+    const own = columnsOf(segments.map(segment => fieldsOf(segment, [...IDENTITY, 'values'])))
+        .map(name => ({ header: `${prefix}${name}`, read: (group) => new Map(fieldsOf(pick(group) ?? {}, [])).get(name) }));
+    const points = new Map();
+    for (const point of segments.flatMap(segment => segment.values)) {
+        points.set(pointId(point), [...points.get(pointId(point)) ?? [], pointCells(point)]);
+    }
+    // Named by `x` alone, the same for every segment; a step's title is a cell of its own, `<x>.title`
+    const pointColumns = [...points.entries()].flatMap(([id, fields]) => columnsOf(fields).map(name => ({
+        header: `${prefix}${name === 'value' ? id : `${id}.${name}`}`,
+        read: (group) => {
+            const point = pick(group)?.values.find(item => pointId(item) === id);
+            return point === undefined ? undefined : new Map(pointCells(point)).get(name);
+        },
+    })));
+    return [...own, ...pointColumns];
+};
+/**
+ * The CSV view, made from the API answer: a header line, then one row per group, the total first (`is_total`
+ * true; its `key` cell is empty, as is the cell of a group whose raw key is null; a key `""` is written `""`).
+ * Columns: `key`, `title`, `is_total`; the numbers of the group in the asked period, then each point's `value`
+ * (named by its `x`) and its other fields as `<x>.<field>` (a funnel step's or retention period's title as
+ * `<x>.title`); the same for the compared period under `compare.`; then every other field of the answer under its
+ * JSON path (`data.value`, `data.compare.value`, `meta.query.timezone`, `meta.query.revenue_basis`, ...), the same
+ * on every row. A group of one period only has empty cells in the other. A null value is an empty cell. No groups:
+ * the header line alone.
+ */
+export const renderCsv = (answer) => {
+    const groups = groupsOf(answer);
+    const main = totalFirst(answer.data.segments);
+    const compare = totalFirst(answer.data.compare?.segments ?? []);
+    const summary = answerFields(answer);
+    const summaryNames = columnsOf([summary]);
+    const summaryCells = new Map(summary);
+    const identity = IDENTITY.map(name => ({
+        header: name,
+        read: group => new Map(fieldsOf(group.main ?? group.compare ?? {}, [])).get(name),
+    }));
+    const columns = [
+        ...identity,
+        ...(main.length === 0
+            ? BASE_COLUMNS.slice(IDENTITY.length).map(name => ({ header: name, read: () => undefined }))
+            : periodColumns(main, '', group => group.main)),
+        ...periodColumns(compare, 'compare.', group => group.compare),
+        ...summaryNames.map(name => ({ header: name, read: () => summaryCells.get(name) })),
+    ];
+    const rows = groups.map(group => columns.map(column => column.read(group)));
+    return [columns.map(column => column.header), ...rows].map(cells => csvLine(cells)).join('\n');
+};
+/**
+ * What a data command writes to stderr: with `--csv`, when the asked period has no segments, `No data for this
+ * period.` and the summary of each period, as the human view shows them (the CSV is then its header alone, or the
+ * groups of the compared period); else nothing, an empty text.
+ */
+export const csvNotice = (answer, csv) => {
+    if (!csv || answer.data.segments.length > 0) {
+        return '';
+    }
+    const sections = sectionsOf(answer).map(section => [
+        ...(section.period === 'compare' ? ['Compared period'] : []),
+        ...(section.segments.length === 0 ? [NO_DATA] : []),
+        ...section.summary.map(field => line(field)),
+    ].join('\n'));
+    return `${sections.join('\n\n')}\n`;
+};

package/dist/commands/analytics/catalog.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/analytics/catalog.js';

package/dist/commands/analytics/catalog.js

@@ -0,0 +1,2 @@
+// Implementation lives in the new cli layer; oclif discovers commands only under src/commands.
+export { default } from '../../cli/commands/analytics/catalog.js';

package/dist/commands/analytics/chart.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/analytics/chart.js';

package/dist/commands/analytics/chart.js

@@ -0,0 +1,2 @@
+// Implementation lives in the new cli layer; oclif discovers commands only under src/commands.
+export { default } from '../../cli/commands/analytics/chart.js';

package/dist/commands/analytics/cohort.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/analytics/cohort.js';

package/dist/commands/analytics/cohort.js

@@ -0,0 +1,2 @@
+// Implementation lives in the new cli layer; oclif discovers commands only under src/commands.
+export { default } from '../../cli/commands/analytics/cohort.js';

package/dist/commands/analytics/conversion.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/analytics/conversion.js';

package/dist/commands/analytics/conversion.js

@@ -0,0 +1,2 @@
+// Implementation lives in the new cli layer; oclif discovers commands only under src/commands.
+export { default } from '../../cli/commands/analytics/conversion.js';

package/dist/commands/analytics/funnel.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/analytics/funnel.js';

package/dist/commands/analytics/funnel.js

@@ -0,0 +1,2 @@
+// Implementation lives in the new cli layer; oclif discovers commands only under src/commands.
+export { default } from '../../cli/commands/analytics/funnel.js';

package/dist/commands/analytics/ltv.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/analytics/ltv.js';

package/dist/commands/analytics/ltv.js

@@ -0,0 +1,2 @@
+// Implementation lives in the new cli layer; oclif discovers commands only under src/commands.
+export { default } from '../../cli/commands/analytics/ltv.js';

package/dist/commands/analytics/retention.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/analytics/retention.js';

package/dist/commands/analytics/retention.js

@@ -0,0 +1,2 @@
+// Implementation lives in the new cli layer; oclif discovers commands only under src/commands.
+export { default } from '../../cli/commands/analytics/retention.js';

package/dist/commands/analytics/values.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/analytics/values.js';

package/dist/commands/analytics/values.js

@@ -0,0 +1,2 @@
+// Implementation lives in the new cli layer; oclif discovers commands only under src/commands.
+export { default } from '../../cli/commands/analytics/values.js';

package/dist/commands/placements/create.js

@@ -18,6 +18,10 @@ export default class PlacementsCreate extends Command {
             description: 'JSON array of audience entries. Every entry needs an explicit content_type. '
                 + 'Paywall: {content_type:"paywall", segment_ids, paywall_id, priority}. '
                 + 'Flow: {content_type:"flow", segment_ids, flow_id, priority}. '
+                + 'A/B test (as `placements get` shows it): {content_type:"ab_test" | "flow_ab_test", ab_test_id, segment_ids, priority}; '
+                + 'crossplacement entries ("cross_ab_test", "flow_cross_ab_test") are read-only, the API keeps the stored ones. '
+                + 'Write the entries of `placements get` back unchanged to keep a running test: a write that removes or replaces '
+                + 'an A/B test entry stops that test with no winner. '
                 + 'A flow must be published first (flows publish) — attaching a draft flow returns 400.',
             exactlyOne: ['paywall-id', 'audiences'],
         }),

package/dist/commands/placements/update.js

@@ -22,6 +22,10 @@ export default class PlacementsUpdate extends Command {
             description: 'JSON array of audience entries. Every entry needs an explicit content_type. '
                 + 'Paywall: {content_type:"paywall", segment_ids, paywall_id, priority}. '
                 + 'Flow: {content_type:"flow", segment_ids, flow_id, priority}. '
+                + 'A/B test (as `placements get` shows it): {content_type:"ab_test" | "flow_ab_test", ab_test_id, segment_ids, priority}; '
+                + 'crossplacement entries ("cross_ab_test", "flow_cross_ab_test") are read-only, the API keeps the stored ones. '
+                + 'Write the entries of `placements get` back unchanged to keep a running test: a write that removes or replaces '
+                + 'an A/B test entry stops that test with no winner. '
                 + 'A flow must be published first (flows publish) — attaching a draft flow returns 400.',
             exactlyOne: ['paywall-id', 'audiences'],
         }),

package/dist/lib/api-schemas.d.ts

@@ -173,7 +173,30 @@ export type PlacementFlowAudienceEntryDTO = {
     priority: number;
     segment_ids?: string[];
 };
-export type PlacementAudienceEntryDTO = PlacementFlowAudienceEntryDTO | PlacementPaywallAudienceEntryDTO;
+/**
+ * An audience that runs a regular A/B test: the running content of the audience is the test.
+ * `ab_test_title` is read-only: the API ignores it on a write. Writing the same `ab_test_id` back
+ * on the same segments keeps the test running; any other id or segment set starts or stops a test.
+ */
+export type PlacementABTestAudienceEntryDTO = {
+    ab_test_id: string;
+    ab_test_title?: string;
+    content_type: 'ab_test' | 'flow_ab_test';
+    priority: number;
+    segment_ids?: string[];
+};
+/**
+ * An audience that shows a crossplacement A/B test (`ab_test_id` is the parent test). Read-only:
+ * the API ignores these entries on a write and keeps the stored ones.
+ */
+export type PlacementCrossABTestAudienceEntryDTO = {
+    ab_test_id: string;
+    ab_test_title?: string;
+    content_type: 'cross_ab_test' | 'flow_cross_ab_test';
+    priority: number;
+    segment_ids?: string[];
+};
+export type PlacementAudienceEntryDTO = PlacementABTestAudienceEntryDTO | PlacementCrossABTestAudienceEntryDTO | PlacementFlowAudienceEntryDTO | PlacementPaywallAudienceEntryDTO;
 export type PlacementSummaryDTO = {
     developer_id: string;
     id: string;

package/dist/lib/placement-audiences.d.ts

@@ -1,6 +1,8 @@
 /**
  * Returns a human-readable problem string when `entry` is not a valid placement
  * audience entry, or `null` when it is well-formed. Every entry must carry an
- * explicit `content_type` ('paywall' | 'flow'); there is no implicit paywall.
+ * explicit `content_type`; there is no implicit paywall. A kind that this CLI does
+ * not know is refused with an "update the CLI" text, never with a text that invites
+ * deleting the entry: a write without a running A/B test entry stops that test.
  */
 export declare function audienceEntryProblem(entry: unknown): null | string;

package/dist/lib/placement-audiences.js

@@ -2,24 +2,31 @@
 // The DTO union in api-schemas.ts requires content_type, but a JSON.parse gives
 // back `unknown`, so the type alone cannot enforce it — this does, the same way
 // for humans and agents (no prompting).
+/** The A/B test audience kinds: regular and crossplacement, paywall and flow. Each needs `ab_test_id`. */
+const A_B_TEST_KINDS = new Set(['ab_test', 'cross_ab_test', 'flow_ab_test', 'flow_cross_ab_test']);
 /**
  * Returns a human-readable problem string when `entry` is not a valid placement
  * audience entry, or `null` when it is well-formed. Every entry must carry an
- * explicit `content_type` ('paywall' | 'flow'); there is no implicit paywall.
+ * explicit `content_type`; there is no implicit paywall. A kind that this CLI does
+ * not know is refused with an "update the CLI" text, never with a text that invites
+ * deleting the entry: a write without a running A/B test entry stops that test.
  */
 export function audienceEntryProblem(entry) {
     if (typeof entry !== 'object' || entry === null) {
         return 'each entry must be a JSON object';
     }
-    const { content_type: contentType, flow_id: flowId, paywall_id: paywallId } = entry;
-    if (contentType !== 'flow' && contentType !== 'paywall') {
-        return 'content_type is required and must be "paywall" or "flow"';
+    const { ab_test_id: abTestId, content_type: contentType, flow_id: flowId, paywall_id: paywallId, } = entry;
+    if (typeof contentType !== 'string') {
+        return 'content_type is required: "paywall", "flow", "ab_test", "flow_ab_test", "cross_ab_test" or "flow_cross_ab_test"';
     }
-    if (contentType === 'paywall' && typeof paywallId !== 'string') {
-        return 'a paywall entry requires paywall_id';
+    if (contentType === 'paywall') {
+        return typeof paywallId === 'string' ? null : 'a paywall entry requires paywall_id';
     }
-    if (contentType === 'flow' && typeof flowId !== 'string') {
-        return 'a flow entry requires flow_id';
+    if (contentType === 'flow') {
+        return typeof flowId === 'string' ? null : 'a flow entry requires flow_id';
     }
-    return null;
+    if (!A_B_TEST_KINDS.has(contentType)) {
+        return 'this CLI does not know this audience kind; update the CLI';
+    }
+    return typeof abTestId === 'string' ? null : `an entry with content_type "${contentType}" requires ab_test_id`;
 }

package/dist/sdk/adapty/analytics/catalog.d.ts

@@ -0,0 +1,51 @@
+/**
+ * What the analytics of an app can answer: the six operations with their options, groupings and filters, every
+ * chart and conversion of the dashboard, and every filter key. Passed through as the server sends it.
+ */
+/** A grouping: `key` is what `--group-by` takes. */
+export type CatalogSegmentation = {
+    key: string;
+    label: string;
+};
+/** One query field: `values` lists the accepted values when they are a fixed set. */
+export type CatalogOption = {
+    default: boolean | null | string;
+    name: string;
+    values: null | string[];
+};
+export type CatalogOperation = {
+    can_compare: boolean;
+    /** Filter keys; for `metrics` they depend on the chart and are in `charts`. */
+    filters: string[];
+    id: string;
+    method: string;
+    options: CatalogOption[];
+    path: string;
+    segmentations: CatalogSegmentation[];
+};
+export type CatalogChart = {
+    default_segmentation: null | string;
+    filters: string[];
+    id: string;
+    segmentations: CatalogSegmentation[];
+    takes_revenue_basis: boolean;
+    title: string;
+    unit: string;
+};
+export type CatalogConversion = {
+    id: string;
+    title: string;
+};
+export type CatalogDimension = {
+    key: string;
+    label: string;
+};
+export type AnalyticsCatalog = {
+    charts: CatalogChart[];
+    conversions: CatalogConversion[];
+    dimensions: CatalogDimension[];
+    operations: CatalogOperation[];
+};
+export type CatalogResponse = {
+    data: AnalyticsCatalog;
+};

package/dist/sdk/adapty/analytics/catalog.js

@@ -0,0 +1,5 @@
+/**
+ * What the analytics of an app can answer: the six operations with their options, groupings and filters, every
+ * chart and conversion of the dashboard, and every filter key. Passed through as the server sends it.
+ */
+export {};

package/dist/sdk/adapty/analytics/chart.d.ts

@@ -0,0 +1,41 @@
+import type { AnalyticsData, AnalyticsMeta, AnalyticsResponse, AnalyticsSegment, PeriodUnit, RevenueBasis } from './model.js';
+import type { ComparableQueryInput, GroupingInput, GroupingRequest, QueryRequest } from './query.js';
+import type { Issue } from '../../core/errors.js';
+/** A chart id as the catalog lists it; the backend knows which ids exist. */
+export type ChartId = string;
+export type ChartInput = ComparableQueryInput & GroupingInput & {
+    chartId: ChartId;
+    /** Money charts only; the backend refuses it for the others (exit 4). */
+    revenueBasis?: RevenueBasis | undefined;
+};
+type ChartRequest = GroupingRequest & QueryRequest & {
+    chart_id: ChartId;
+    revenue_basis?: RevenueBasis;
+};
+export type ChartPoint = {
+    value: number;
+    x: string;
+};
+export type ChartSegment = AnalyticsSegment & {
+    value: number;
+    values: ChartPoint[];
+};
+export type ChartData = AnalyticsData<ChartSegment> & {
+    /** The compared period, built from that period only; null without one and when neither period has rows. */
+    compare: null | {
+        segments: ChartSegment[];
+        value: number;
+    };
+    value: number;
+};
+export type ChartMeta = AnalyticsMeta<{
+    chart_id: ChartId;
+    period_unit: PeriodUnit;
+    /** Null for a chart that is not about money. */
+    revenue_basis: null | RevenueBasis;
+    segmentation: null | string;
+}>;
+export type ChartResponse = AnalyticsResponse<ChartData, ChartMeta>;
+export declare const validateChart: (input: ChartInput) => Issue[];
+export declare const toChartRequest: (input: ChartInput) => ChartRequest;
+export {};

package/dist/sdk/adapty/analytics/chart.js

@@ -0,0 +1,6 @@
+import { toGroupingRequest, toQueryRequest, validateComparableQuery } from './query.js';
+export const validateChart = (input) => validateComparableQuery(input);
+export const toChartRequest = (input) => {
+    const body = { chart_id: input.chartId, ...toQueryRequest(input), ...toGroupingRequest(input) };
+    return input.revenueBasis === undefined ? body : { ...body, revenue_basis: input.revenueBasis };
+};

package/dist/sdk/adapty/analytics/cohort.d.ts

@@ -0,0 +1,79 @@
+import type { AnalyticsData, AnalyticsMeta, AnalyticsResponse, AnalyticsSegment, Money, PeriodUnit } from './model.js';
+import type { GroupingInput, GroupingRequest } from './query.js';
+import type { RenewalPeriodsInput, RenewalPeriodsQuery, RenewalPeriodsRequest } from './renewal-periods.js';
+import type { Issue } from '../../core/errors.js';
+/** No grouping: each segment is one cohort already. `granularity` is the length of one cohort. */
+export type CohortInput = Pick<GroupingInput, 'granularity'> & RenewalPeriodsInput;
+type CohortRequest = Pick<GroupingRequest, 'period_unit'> & RenewalPeriodsRequest;
+/**
+ * One period of a cohort. `value` and `value_relative` are the revenue on the asked basis; the money fields
+ * give each basis.
+ */
+export type CohortPoint = {
+    arpas: Money;
+    arppu: Money;
+    arpu: Money;
+    currently_active_period: boolean;
+    installs: number;
+    revenue: Money;
+    revenue_relative: Money;
+    subscribers: number;
+    subscribers_relative: number;
+    subscriptions: number;
+    subscriptions_relative: number;
+    value: number;
+    value_relative: number;
+    x: number;
+};
+/** Predicted revenue (`rev*`) and LTV (`ltv*`) after 3..24 months; null where the backend cannot predict. */
+export type PredictValues = {
+    ltv3: null | number;
+    ltv6: null | number;
+    ltv9: null | number;
+    ltv12: null | number;
+    ltv18: null | number;
+    ltv24: null | number;
+    rev3: null | number;
+    rev6: null | number;
+    rev9: null | number;
+    rev12: null | number;
+    rev18: null | number;
+    rev24: null | number;
+};
+/** The backend predictions per basis (`gross_v2`: its second gross model); a section is null where it gives none. */
+export type CohortPredict = {
+    gross: null | PredictValues;
+    gross_v2: null | PredictValues;
+    net: null | PredictValues;
+    proceeds: null | PredictValues;
+    status: null | {
+        status_3: null | number;
+        status_6: null | number;
+        status_9: null | number;
+        status_12: null | number;
+        status_18: null | number;
+        status_24: null | number;
+    };
+};
+/** One cohort, its start date as `key` (null for the total); `value` is its revenue on the asked basis. */
+export type CohortSegment = AnalyticsSegment & {
+    arpas: Money;
+    arppu: Money;
+    arpu: Money;
+    installs: number;
+    predict: CohortPredict | null;
+    revenue: Money;
+    start_date: null | string;
+    subscribers: number;
+    subscriptions: number;
+    value: number;
+    values: CohortPoint[];
+};
+export type CohortData = AnalyticsData<CohortSegment>;
+export type CohortMeta = AnalyticsMeta<RenewalPeriodsQuery & {
+    period_unit: PeriodUnit;
+}>;
+export type CohortResponse = AnalyticsResponse<CohortData, CohortMeta>;
+export declare const validateCohort: (input: CohortInput) => Issue[];
+export declare const toCohortRequest: (input: CohortInput) => CohortRequest;
+export {};

package/dist/sdk/adapty/analytics/cohort.js

@@ -0,0 +1,4 @@
+import { toGroupingRequest } from './query.js';
+import { toRenewalPeriodsRequest, validateRenewalPeriods } from './renewal-periods.js';
+export const validateCohort = (input) => validateRenewalPeriods(input);
+export const toCohortRequest = (input) => ({ ...toRenewalPeriodsRequest(input), ...toGroupingRequest(input) });

package/dist/sdk/adapty/analytics/conversion.d.ts

@@ -0,0 +1,55 @@
+import type { AnalyticsData, AnalyticsMeta, AnalyticsResponse, AnalyticsSegment, PeriodUnit } from './model.js';
+import type { ComparableQueryInput, GroupingInput, GroupingRequest, QueryRequest } from './query.js';
+import type { Issue } from '../../core/errors.js';
+/** A conversion id as the catalog lists it; the backend knows which ids exist and never maps one id to another pair. */
+export type ConversionId = string;
+export type ConversionInput = ComparableQueryInput & GroupingInput & {
+    conversionId: ConversionId;
+};
+type ConversionRequest = GroupingRequest & QueryRequest & {
+    conversion_id: ConversionId;
+};
+export type ConversionPoint = {
+    has_unfinished: boolean;
+    value: number;
+    value_from: number;
+    value_from_unfinished: number;
+    value_to: number;
+    x: string;
+};
+/** `value` is the conversion in percent: `value_to` of `value_from`. */
+/** `value_from` and `value_to` are null only on a compared total that the backend does not give. */
+export type ConversionSegment = AnalyticsSegment & {
+    value: number;
+    value_from: null | number;
+    value_to: null | number;
+    values: ConversionPoint[];
+};
+export type ConversionData = AnalyticsData<ConversionSegment> & {
+    /** The counts of the compared period itself; null when the backend has no total row for it. */
+    compare: null | {
+        segments: ConversionSegment[];
+        value: number;
+        value_from: null | number;
+        value_to: null | number;
+    };
+    value: number;
+    value_from: number;
+    value_to: number;
+};
+export type ConversionMeta = AnalyticsMeta<{
+    conversion_id: ConversionId;
+    period_unit: PeriodUnit;
+    segmentation: null | string;
+}> & {
+    /** A window with data, given when the asked window has none. */
+    recommended_period: null | {
+        date_from: string;
+        date_to: string;
+        period_unit: string;
+    };
+};
+export type ConversionResponse = AnalyticsResponse<ConversionData, ConversionMeta>;
+export declare const validateConversion: (input: ConversionInput) => Issue[];
+export declare const toConversionRequest: (input: ConversionInput) => ConversionRequest;
+export {};

package/dist/sdk/adapty/analytics/conversion.js

@@ -0,0 +1,7 @@
+import { toGroupingRequest, toQueryRequest, validateComparableQuery } from './query.js';
+export const validateConversion = (input) => validateComparableQuery(input);
+export const toConversionRequest = (input) => ({
+    conversion_id: input.conversionId,
+    ...toQueryRequest(input),
+    ...toGroupingRequest(input),
+});