adapty 0.11.0 → 0.13.0

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

@@ -0,0 +1,134 @@
+import { formatValue, line, NO_DATA, NO_VALUE, pointId, pointLabel, renderCsv, sectionsOf, } from './segments.js';
+const asGiven = (value) => {
+    if (typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return NO_VALUE;
+};
+const money = value => (typeof value === 'number' ? value.toFixed(2) : asGiven(value));
+const text = (value) => (typeof value === 'string' && value !== '' ? value : undefined);
+const groupedBy = (query) => {
+    const segmentation = text(query.segmentation);
+    return segmentation === undefined ? undefined : `by ${segmentation}`;
+};
+const perPeriod = (query) => {
+    if (query.period_type === 'renewals') {
+        return 'per renewal';
+    }
+    return query.period_type === 'days' ? 'per day' : undefined;
+};
+const isMoneyChart = (query) => text(query.revenue_basis) !== undefined;
+export const chartTable = {
+    columns: query => [{ field: 'value', format: isMoneyChart(query) ? money : asGiven, header: 'Total' }],
+    points: query => (isMoneyChart(query) ? money : asGiven),
+    title: query => [['Chart', text(query.chart_id)].filter(part => part !== undefined).join(' '), text(query.revenue_basis), groupedBy(query)],
+};
+export const conversionTable = {
+    columns: () => [
+        { field: 'value', format: asGiven, header: 'Conversion %' },
+        { field: 'value_from', format: asGiven, header: 'From' },
+        { field: 'value_to', format: asGiven, header: 'To' },
+    ],
+    omitted: 'the counts of each point (value_from, value_to, value_from_unfinished, has_unfinished)',
+    points: () => asGiven,
+    title: query => [['Conversion', text(query.conversion_id)].filter(part => part !== undefined).join(' '), groupedBy(query)],
+};
+export const funnelTable = {
+    columns: () => [{ field: 'value', format: asGiven, header: 'Installs' }],
+    omitted: 'the share of each step, the change to the next step, churn reasons and parts',
+    points: () => asGiven,
+    title: query => ['Funnel', groupedBy(query)],
+};
+export const retentionTable = {
+    columns: () => [{ field: 'value', format: asGiven, header: 'Subscribers' }],
+    omitted: 'the share of each period (value_relative)',
+    points: () => asGiven,
+    title: query => ['Retention', query.use_trial === true ? 'from the trial' : undefined, groupedBy(query)],
+};
+export const ltvTable = {
+    columns: () => [
+        { field: 'value', format: money, header: 'LTV' },
+        { field: 'cohort_size', format: asGiven, header: 'Cohort size' },
+    ],
+    points: () => money,
+    title: query => ['LTV', text(query.revenue_basis), perPeriod(query), groupedBy(query)],
+};
+export const cohortTable = {
+    columns: () => [
+        { field: 'value', format: money, header: 'Revenue' },
+        { field: 'installs', format: asGiven, header: 'Installs' },
+        { field: 'subscribers', format: asGiven, header: 'Subscribers' },
+    ],
+    omitted: 'revenue, ARPU, ARPPU and ARPAS on each basis, subscriptions, the shares of each period, predictions',
+    points: () => money,
+    title: query => ['Cohorts', text(query.revenue_basis), perPeriod(query)],
+};
+const range = (dates) => (Array.isArray(dates) && dates.length > 0 ? dates.join(' – ') : undefined);
+const PERIOD_KEYS = new Set(['compare_date', 'date']);
+/** The filters besides the period, as `--filter` takes them. */
+const filtersOf = (filters) => {
+    const given = Object.entries(filters).filter(([dimension]) => !PERIOD_KEYS.has(dimension))
+        .map(([dimension, values]) => `${dimension}=${values.map(value => value.replaceAll(',', String.raw `\,`)).join(',')}`);
+    return given.length === 0 ? undefined : `filters ${given.join(' ')}`;
+};
+const TIMEZONE_SOURCES = { app: 'from the app', request: 'from --timezone' };
+/** The period, the length of one point, the time zone and where it comes from, and the filters. */
+const periodLine = (query) => {
+    const filters = (query.filters ?? {});
+    const source = TIMEZONE_SOURCES[String(query.timezone_source)];
+    const zone = text(query.timezone);
+    const timezone = zone === undefined ? undefined : `time zone ${zone}${source === undefined ? '' : ` (${source})`}`;
+    return [range(filters.date), text(query.period_unit), timezone, filtersOf(filters)]
+        .filter(part => part !== undefined).join(', ');
+};
+/** Rows of cells, the first column left-aligned, the numbers right-aligned, two spaces between. */
+const table = (rows) => {
+    const widths = rows[0]?.map((_, column) => Math.max(...rows.map(row => row[column]?.length ?? 0))) ?? [];
+    return rows.map(row => row.map((cell, column) => (column === 0
+        ? cell.padEnd(widths[column] ?? 0)
+        : cell.padStart(widths[column] ?? 0))).join('  ').trimEnd()).join('\n');
+};
+const fieldOf = (value, name) => value[name];
+/** One row per group, the total first (as `sectionsOf` orders them), then one column per point in first-seen order. */
+const tableOf = (spec, query, segments) => {
+    const columns = spec.columns(query);
+    const format = spec.points(query);
+    const points = new Map();
+    for (const point of segments.flatMap(segment => segment.values)) {
+        if (!points.has(pointId(point))) {
+            points.set(pointId(point), pointLabel(point));
+        }
+    }
+    const rows = segments.map(segment => [
+        formatValue(segment.title),
+        ...columns.map(column => column.format(fieldOf(segment, column.field))),
+        ...[...points.keys()].map(id => format(fieldOf(segment.values.find(point => pointId(point) === id) ?? {}, 'value'))),
+    ]);
+    return table([['', ...columns.map(column => column.header), ...points.values()], ...rows]);
+};
+const comparedHeading = (query) => {
+    const dates = range((query.filters ?? {}).compare_date);
+    return dates === undefined ? 'Compared period' : `Compared period: ${dates}`;
+};
+/**
+ * The heading (what, by which grouping; the period, its time zone and filters), then the table of the asked
+ * period and, when there is one, of the compared period. A period without groups: `No data for this period.` and
+ * the summary of that period, every field, null as `—`.
+ */
+export const humanView = (spec) => (answer) => {
+    const query = answer.meta.query;
+    const sections = sectionsOf(answer);
+    const bodies = sections.map((section) => {
+        const heading = section.period === 'compare' ? [comparedHeading(query)] : [];
+        if (section.segments.length === 0) {
+            return [...heading, NO_DATA, ...section.summary.map(field => line(field))].join('\n');
+        }
+        return [...heading, tableOf(spec, query, section.segments)].join('\n');
+    });
+    const hasTable = sections.some(section => section.segments.length > 0);
+    const more = spec.omitted !== undefined && hasTable ? [`--json and --csv give every field: ${spec.omitted}.`] : [];
+    const title = spec.title(query).filter(part => part !== undefined).join(', ');
+    return [[title, periodLine(query)].join('\n'), ...bodies, ...more].join('\n\n');
+};
+/** The view of a data command: the CSV with `--csv`, else the human table (`--json` prints no view at all). */
+export const analyticsView = (csv, spec) => (answer) => (csv ? renderCsv(answer) : humanView(spec)(answer));

package/dist/cli/views/analytics/segments.d.ts

@@ -0,0 +1,68 @@
+import type { Cell } from './csv.js';
+import type { AnalyticsSegment } from '../../../sdk/adapty/index.js';
+/**
+ * The CSV of the six analytics operations and the summary of a period, made from the answer itself: every field
+ * the API gives is printed, under the name it has in --json, so a field the backend adds is never dropped. A nested
+ * field has a dotted name (`revenue.gross`, `following_changes.value`), a list item its index (`parts[0].value`).
+ * The human table, which shows the main fields only, is in `human.ts`.
+ */
+export type Segment = AnalyticsSegment & {
+    values: readonly object[];
+};
+type Segments = {
+    segments: readonly Segment[];
+};
+/** What every analytics answer has; `compare` only a chart and a conversion, null without a compared period. */
+export type AnalyticsAnswer = {
+    data: Segments & {
+        compare?: null | Segments;
+    };
+    meta: {
+        query: object;
+    };
+};
+type Field = readonly [name: string, value: Cell];
+/** `main` is the asked period; `compare` the compared one. */
+type Section = {
+    period: 'compare' | 'main';
+    segments: readonly Segment[];
+    /** The numbers of the whole period and, for the asked one, the resolved query and the other `meta` fields. */
+    summary: Field[];
+};
+/** A number the backend does not have is null, and printing it as 0 would be a lie. */
+export declare const NO_VALUE = "\u2014";
+export declare const NO_DATA = "No data for this period.";
+/** An empty text (the key of a "No Data" group, for example) is shown as `""`, so it never reads as a missing value. */
+export declare const formatValue: (value: Cell) => string;
+/** A point is found by its `x`. */
+export declare const pointId: (point: object) => string;
+/**
+ * How the human view names a point: its `x` (a period start as its date, `2026-09-22`), and for a funnel step or a
+ * retention period also its title, the number once (`-2 Install`, `1 Paid`, `2 Period`). The CSV keeps the raw `x`.
+ */
+export declare const pointLabel: (point: object) => string;
+/**
+ * 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 declare const sectionsOf: (answer: AnalyticsAnswer) => Section[];
+export declare const line: ([name, value]: Field) => string;
+/**
+ * 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 declare const renderCsv: (answer: AnalyticsAnswer) => string;
+/**
+ * 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 declare const csvNotice: (answer: AnalyticsAnswer, csv: boolean) => string;
+export {};

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

@@ -0,0 +1,189 @@
+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);
+/** A period start as the backend gives it: a date, a time and an offset, as in `2026-09-22T00:00:00.000000+0200`. */
+const TIMESTAMP = /^(\d{4}-\d{2}-\d{2})T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}(?::?\d{2})?)?$/;
+/** The date of a period start in the period's own time zone: the date part as given, with no conversion. */
+const dateOf = (id) => TIMESTAMP.exec(id)?.[1] ?? id;
+/**
+ * How the human view names a point: its `x` (a period start as its date, `2026-09-22`), and for a funnel step or a
+ * retention period also its title, the number once (`-2 Install`, `1 Paid`, `2 Period`). The CSV keeps the raw `x`.
+ */
+export const pointLabel = (point) => {
+    const { title } = point;
+    const id = dateOf(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/product-offers/create.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/product-offers/create.js';

package/dist/commands/product-offers/create.js

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

package/dist/commands/product-offers/get.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/product-offers/get.js';

package/dist/commands/product-offers/get.js

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

package/dist/commands/product-offers/list.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/product-offers/list.js';

package/dist/commands/product-offers/list.js

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

package/dist/commands/product-offers/update.d.ts

@@ -0,0 +1 @@
+export { default } from '../../cli/commands/product-offers/update.js';

package/dist/commands/product-offers/update.js

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

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

@@ -43,6 +43,7 @@ export type AccessLevelUpdateRequestDTO = {
 export type ProductDTO = {
     access_level_id: string;
     id: string;
+    offers_count: number;
     period: ProductPeriod;
     title: string;
     vendor_products: Record<string, VendorProductDTO>;

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 };
+};