adapty 0.11.0 → 0.13.0

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

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

@@ -0,0 +1,41 @@
+import type { AnalyticsData, AnalyticsMeta, AnalyticsResponse, AnalyticsSegment } from './model.js';
+import type { AnalyticsQueryInput, GroupingInput, GroupingRequest, QueryRequest } from './query.js';
+import type { Issue } from '../../core/errors.js';
+/** No compared period: the funnel query mixes two date ranges into one, so the backend refuses it. */
+export type FunnelInput = AnalyticsQueryInput & Pick<GroupingInput, 'groupBy'>;
+type FunnelRequest = Pick<GroupingRequest, 'segmentation'> & QueryRequest;
+/** A count with its share in percent: a drop-off or pick-up, a churn reason, a part of a step. */
+export type Share = {
+    title: string;
+    value: number;
+    value_relative: number;
+};
+/**
+ * One funnel step: `x` is the backend step number. `relative_changes` is the share that reaches the next step,
+ * `following_changes` the drop-off (or pick-up) to it, `churn_reasons` why users left before this step, and
+ * `parts` splits the first paid step into Install → Paid and Trial → Paid.
+ */
+export type FunnelStep = {
+    churn_reason_title: string;
+    churn_reasons: Share[];
+    following_changes: Share;
+    parts: Share[];
+    relative_changes: number;
+    title: string;
+    value: number;
+    value_relative: number;
+    x: number;
+};
+/** `value` is the first step, the installs; null for a segment without steps. */
+export type FunnelSegment = AnalyticsSegment & {
+    value: null | number;
+    values: FunnelStep[];
+};
+export type FunnelData = AnalyticsData<FunnelSegment>;
+export type FunnelMeta = AnalyticsMeta<{
+    segmentation: null | string;
+}>;
+export type FunnelResponse = AnalyticsResponse<FunnelData, FunnelMeta>;
+export declare const validateFunnel: (input: FunnelInput) => Issue[];
+export declare const toFunnelRequest: (input: FunnelInput) => FunnelRequest;
+export {};

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

@@ -0,0 +1,3 @@
+import { toGroupingRequest, toQueryRequest, validateQuery } from './query.js';
+export const validateFunnel = (input) => validateQuery(input);
+export const toFunnelRequest = (input) => ({ ...toQueryRequest(input), ...toGroupingRequest(input) });

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

@@ -0,0 +1,24 @@
+/**
+ * The door of the analytics resource: re-exports only, and only what a consumer uses. The request builders
+ * and the shapes inside an answer stay private to their operation.
+ */
+export { validateChart } from './chart.js';
+export { validateCohort } from './cohort.js';
+export { validateConversion } from './conversion.js';
+export { validateFunnel } from './funnel.js';
+export { validateLtv } from './ltv.js';
+export { periodTypes, periodUnits, revenueBases } from './model.js';
+export { analytics } from './resource.js';
+export { validateRetention } from './retention.js';
+export { validateFilterValues } from './values.js';
+export type { CatalogChart, CatalogOperation, CatalogOption, CatalogResponse, CatalogSegmentation, } from './catalog.js';
+export type { ChartInput, ChartResponse } from './chart.js';
+export type { CohortInput, CohortResponse } from './cohort.js';
+export type { ConversionInput, ConversionResponse } from './conversion.js';
+export type { FunnelInput, FunnelResponse } from './funnel.js';
+export type { LtvInput, LtvResponse } from './ltv.js';
+export type { AnalyticsSegment, PeriodUnit } from './model.js';
+export type { AnalyticsFilter } from './query.js';
+export type { AnalyticsApi } from './resource.js';
+export type { RetentionInput, RetentionResponse } from './retention.js';
+export type { FilterValue, FilterValuesInput, FilterValuesResponse } from './values.js';

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

@@ -0,0 +1,13 @@
+/**
+ * The door of the analytics resource: re-exports only, and only what a consumer uses. The request builders
+ * and the shapes inside an answer stay private to their operation.
+ */
+export { validateChart } from './chart.js';
+export { validateCohort } from './cohort.js';
+export { validateConversion } from './conversion.js';
+export { validateFunnel } from './funnel.js';
+export { validateLtv } from './ltv.js';
+export { periodTypes, periodUnits, revenueBases } from './model.js';
+export { analytics } from './resource.js';
+export { validateRetention } from './retention.js';
+export { validateFilterValues } from './values.js';

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

@@ -0,0 +1,27 @@
+import type { AnalyticsData, AnalyticsMeta, AnalyticsResponse, AnalyticsSegment } 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';
+export type LtvInput = Pick<GroupingInput, 'groupBy'> & RenewalPeriodsInput;
+type LtvRequest = Pick<GroupingRequest, 'segmentation'> & RenewalPeriodsRequest;
+/** `value` is null for a renewal period (or day) that the cohort has not reached yet. */
+export type LtvPoint = {
+    value: null | number;
+    x: number;
+};
+/** `cohort_size` is null on a total that the backend does not give. */
+export type LtvSegment = AnalyticsSegment & {
+    cohort_size: null | number;
+    value: number;
+    values: LtvPoint[];
+};
+export type LtvData = AnalyticsData<LtvSegment> & {
+    value: number;
+};
+export type LtvMeta = AnalyticsMeta<RenewalPeriodsQuery & {
+    segmentation: null | string;
+}>;
+export type LtvResponse = AnalyticsResponse<LtvData, LtvMeta>;
+export declare const validateLtv: (input: LtvInput) => Issue[];
+export declare const toLtvRequest: (input: LtvInput) => LtvRequest;
+export {};

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

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

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

@@ -0,0 +1,53 @@
+/**
+ * What the six analytics operations share: one answer shape, so one parser reads all of them. Answers pass
+ * through as the server sends them, in snake_case: that object is what --json prints.
+ *
+ * `data.segments` starts with the total (`is_total` true); every other segment is one group, and its `key` is the
+ * raw value that the backend gives for that group. No rows for the window: `segments` is empty.
+ * A number is the backend's number: 0 stays 0, and null means the backend has no value.
+ */
+/** The vocabularies of the query fields, in the order the catalog lists them. */
+export declare const periodUnits: readonly ["day", "week", "month", "quarter", "year"];
+export type PeriodUnit = (typeof periodUnits)[number];
+export declare const revenueBases: readonly ["gross", "proceeds", "net"];
+export type RevenueBasis = (typeof revenueBases)[number];
+export declare const periodTypes: readonly ["renewals", "days"];
+export type PeriodType = (typeof periodTypes)[number];
+export type AnalyticsSegment = {
+    /** The one way to tell the total from a group: a group's `key` can be null too. */
+    is_total: boolean;
+    /**
+     * The raw value that the backend gives for the group, as the dashboard has it; null for the total. Any value is
+     * possible, null, `""` and `"None"` (a "No Data" group) included. It is not promised to be a `--filter` value.
+     */
+    key: null | string;
+    /** The backend title, "No Data" included. */
+    title: string;
+};
+/**
+ * The query that ran: every field of the operation with its default, the filters as sent, the time zone and
+ * where it comes from (`request` for `--timezone`, else `app`).
+ */
+export type ResolvedQuery<Fields> = Fields & {
+    filters: Record<string, string[]>;
+    timezone: string;
+    timezone_source: 'app' | 'request';
+};
+export type AnalyticsMeta<Fields = Record<string, unknown>> = {
+    query: ResolvedQuery<Fields>;
+};
+/** One amount in USD on each revenue basis. */
+export type Money = {
+    gross: number;
+    net: number;
+    proceeds: number;
+};
+export type AnalyticsResponse<Data, Meta> = {
+    data: Data;
+    meta: Meta;
+};
+/** Every data answer has these: the main number and the segments, total first. */
+export type AnalyticsData<Segment extends AnalyticsSegment> = {
+    segments: Segment[];
+    value: null | number;
+};

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

@@ -0,0 +1,12 @@
+/**
+ * What the six analytics operations share: one answer shape, so one parser reads all of them. Answers pass
+ * through as the server sends them, in snake_case: that object is what --json prints.
+ *
+ * `data.segments` starts with the total (`is_total` true); every other segment is one group, and its `key` is the
+ * raw value that the backend gives for that group. No rows for the window: `segments` is empty.
+ * A number is the backend's number: 0 stays 0, and null means the backend has no value.
+ */
+/** The vocabularies of the query fields, in the order the catalog lists them. */
+export const periodUnits = ['day', 'week', 'month', 'quarter', 'year'];
+export const revenueBases = ['gross', 'proceeds', 'net'];
+export const periodTypes = ['renewals', 'days'];

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

@@ -0,0 +1,48 @@
+import type { PeriodUnit } from './model.js';
+import type { Issue } from '../../core/errors.js';
+/** One filter: a dimension key from the catalog and the raw values it keeps (any of them). */
+export type AnalyticsFilter = {
+    dimension: string;
+    values: readonly string[];
+};
+/** What every operation takes. Dates are inclusive days of the query time zone, `YYYY-MM-DD`. */
+export type AnalyticsQueryInput = {
+    appId: string;
+    dateFrom: string;
+    dateTo: string;
+    filters?: readonly AnalyticsFilter[] | undefined;
+    /** An IANA name; the app time zone when left out. Which names exist is the backend's knowledge. */
+    timezone?: string | undefined;
+};
+/** The two operations whose query keeps two periods apart: a chart and a conversion. */
+export type ComparableQueryInput = AnalyticsQueryInput & {
+    compareFrom?: string | undefined;
+    compareTo?: string | undefined;
+};
+/** `date` and `compare_date` are `[start, end]`; every other key is a dimension with its values. */
+export type FiltersRequest = Record<string, string[]>;
+export type QueryRequest = {
+    filters: FiltersRequest;
+    timezone?: string;
+};
+export declare const validateQuery: (input: AnalyticsQueryInput) => Issue[];
+/** A compared period is both ends or neither, and a real range: the backend has no default for half of one. */
+export declare const validateComparableQuery: (input: ComparableQueryInput) => Issue[];
+/**
+ * The fields every operation sends. Filters are a map of dimension to values, as the dashboard sends them: two
+ * filters of one dimension become one list (a value kept by either is kept by the union), each value once.
+ * An absent timezone is left out, so the backend applies the app zone and says so in `meta.query`.
+ */
+export declare const toQueryRequest: (input: ComparableQueryInput) => QueryRequest;
+/** The grouping and the period of one point, as the operations that take them name them. */
+export type GroupingInput = {
+    granularity?: PeriodUnit | undefined;
+    /** A grouping key of the operation (of the chart, for a chart), as the catalog lists it. */
+    groupBy?: string | undefined;
+};
+export type GroupingRequest = {
+    period_unit?: PeriodUnit;
+    segmentation?: string;
+};
+/** The input names meet the API names here, once for every operation; a field left out stays out. */
+export declare const toGroupingRequest: (input: GroupingInput) => GroupingRequest;

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

@@ -0,0 +1,52 @@
+import { validateDayRange } from '../../core/dates.js';
+/** The period has flags of its own; as a filter it would replace them without a word. */
+const PERIOD_KEYS = new Set(['compare_date', 'date']);
+export const validateQuery = (input) => {
+    const issues = validateDayRange(input.dateFrom, input.dateTo, { from: 'dateFrom', to: 'dateTo' });
+    for (const filter of input.filters ?? []) {
+        if (PERIOD_KEYS.has(filter.dimension)) {
+            issues.push({ message: `${filter.dimension} is not a filter: the period has flags of its own`, path: 'filter' });
+        }
+    }
+    return issues;
+};
+/** A compared period is both ends or neither, and a real range: the backend has no default for half of one. */
+export const validateComparableQuery = (input) => {
+    const issues = validateQuery(input);
+    const { compareFrom, compareTo } = input;
+    if (compareFrom === undefined && compareTo === undefined) {
+        return issues;
+    }
+    if (compareFrom === undefined) {
+        return [...issues, { fields: ['compareTo'], message: 'required with {compareTo}', path: 'compareFrom' }];
+    }
+    if (compareTo === undefined) {
+        return [...issues, { fields: ['compareFrom'], message: 'required with {compareFrom}', path: 'compareTo' }];
+    }
+    return [...issues, ...validateDayRange(compareFrom, compareTo, { from: 'compareFrom', to: 'compareTo' })];
+};
+/**
+ * The fields every operation sends. Filters are a map of dimension to values, as the dashboard sends them: two
+ * filters of one dimension become one list (a value kept by either is kept by the union), each value once.
+ * An absent timezone is left out, so the backend applies the app zone and says so in `meta.query`.
+ */
+export const toQueryRequest = (input) => {
+    const filters = { date: [input.dateFrom, input.dateTo] };
+    if (input.compareFrom !== undefined && input.compareTo !== undefined) {
+        filters.compare_date = [input.compareFrom, input.compareTo];
+    }
+    for (const filter of input.filters ?? []) {
+        const known = filters[filter.dimension] ?? [];
+        filters[filter.dimension] = [...new Set([...known, ...filter.values])];
+    }
+    const body = { filters };
+    if (input.timezone !== undefined) {
+        body.timezone = input.timezone;
+    }
+    return body;
+};
+/** The input names meet the API names here, once for every operation; a field left out stays out. */
+export const toGroupingRequest = (input) => ({
+    ...(input.granularity === undefined ? {} : { period_unit: input.granularity }),
+    ...(input.groupBy === undefined ? {} : { segmentation: input.groupBy }),
+});

package/dist/sdk/adapty/analytics/renewal-periods.d.ts

@@ -0,0 +1,23 @@
+import type { PeriodType, RevenueBasis } from './model.js';
+import type { AnalyticsQueryInput, QueryRequest } from './query.js';
+import type { Issue } from '../../core/errors.js';
+/** What LTV and cohorts share: revenue on a basis, counted per renewal or per day. */
+export type RenewalPeriodsInput = AnalyticsQueryInput & {
+    periodType?: PeriodType | undefined;
+    /** Whole days, 0 or more; only with `periodType: 'days'`. The backend list applies when left out. */
+    renewalDays?: readonly number[] | undefined;
+    revenueBasis?: RevenueBasis | undefined;
+};
+/** The fields of the resolved query that LTV and cohorts share. */
+export type RenewalPeriodsQuery = {
+    period_type: PeriodType;
+    renewal_days: null | number[];
+    revenue_basis: RevenueBasis;
+};
+export type RenewalPeriodsRequest = QueryRequest & {
+    period_type?: PeriodType;
+    renewal_days?: number[];
+    revenue_basis?: RevenueBasis;
+};
+export declare const validateRenewalPeriods: (input: RenewalPeriodsInput) => Issue[];
+export declare const toRenewalPeriodsRequest: (input: RenewalPeriodsInput) => RenewalPeriodsRequest;

package/dist/sdk/adapty/analytics/renewal-periods.js

@@ -0,0 +1,27 @@
+import { toQueryRequest, validateQuery } from './query.js';
+export const validateRenewalPeriods = (input) => {
+    const issues = validateQuery(input);
+    if (input.renewalDays !== undefined && input.periodType !== 'days') {
+        issues.push({ fields: ['periodType'], message: 'needs {periodType} days', path: 'renewalDays' });
+    }
+    // The backend reads the list as given: whole days, ascending, each once; anything else it refuses
+    const days = input.renewalDays ?? [];
+    const ordered = days.every((day, index) => index === 0 || day > (days[index - 1] ?? day));
+    if (days.some(day => !Number.isInteger(day) || day < 0) || !ordered) {
+        issues.push({ message: 'must be whole days, 0 or more, in ascending order, each day once', path: 'renewalDays' });
+    }
+    return issues;
+};
+export const toRenewalPeriodsRequest = (input) => {
+    const body = toQueryRequest(input);
+    if (input.revenueBasis !== undefined) {
+        body.revenue_basis = input.revenueBasis;
+    }
+    if (input.periodType !== undefined) {
+        body.period_type = input.periodType;
+    }
+    if (input.renewalDays !== undefined) {
+        body.renewal_days = [...input.renewalDays];
+    }
+    return body;
+};

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

@@ -0,0 +1,29 @@
+import type { CatalogResponse } from './catalog.js';
+import type { ChartInput, ChartResponse } from './chart.js';
+import type { CohortInput, CohortResponse } from './cohort.js';
+import type { ConversionInput, ConversionResponse } from './conversion.js';
+import type { FunnelInput, FunnelResponse } from './funnel.js';
+import type { LtvInput, LtvResponse } from './ltv.js';
+import type { RetentionInput, RetentionResponse } from './retention.js';
+import type { FilterValuesInput, FilterValuesResponse } from './values.js';
+import type { Http } from '../../core/http/index.js';
+/**
+ * Every path of the analytics of an app in one place. The catalog and the values are GETs and keep the
+ * transport's retry. The six operations are POSTs that run analytics queries under the rate limits of each route
+ * (2 requests per second per app and 360 per minute for all callers together, as the Export API): sent once,
+ * never retried, and a 429 reaches the caller with the server's wait.
+ *
+ * The validating methods are async on purpose — a broken rule then arrives as a rejected promise, like a
+ * network failure, and one await covers both.
+ */
+export declare const analytics: (http: Http) => {
+    catalog: (appId: string) => Promise<CatalogResponse>;
+    chart: (input: ChartInput) => Promise<ChartResponse>;
+    cohort: (input: CohortInput) => Promise<CohortResponse>;
+    conversion: (input: ConversionInput) => Promise<ConversionResponse>;
+    funnel: (input: FunnelInput) => Promise<FunnelResponse>;
+    ltv: (input: LtvInput) => Promise<LtvResponse>;
+    retention: (input: RetentionInput) => Promise<RetentionResponse>;
+    values: (input: FilterValuesInput) => Promise<FilterValuesResponse>;
+};
+export type AnalyticsApi = ReturnType<typeof analytics>;

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

@@ -0,0 +1,72 @@
+import { ApiError } from '../../core/errors.js';
+import { assertValid } from '../../core/validation.js';
+import { toChartRequest, validateChart } from './chart.js';
+import { toCohortRequest, validateCohort } from './cohort.js';
+import { toConversionRequest, validateConversion } from './conversion.js';
+import { toFunnelRequest, validateFunnel } from './funnel.js';
+import { toLtvRequest, validateLtv } from './ltv.js';
+import { toRetentionRequest, validateRetention } from './retention.js';
+import { validateFilterValues } from './values.js';
+const base = (appId) => `/apps/${appId}/analytics`;
+const isObject = (value) => typeof value === 'object' && value !== null;
+const dataOf = (body) => (isObject(body) ? body.data : undefined);
+/** A data answer: `data.segments` is the list every view reads. */
+const hasSegments = (data) => isObject(data) && Array.isArray(data.segments);
+/**
+ * The transport hands back whatever a success body parsed to, and a proxy's HTML page parses to a string.
+ * Passed on, it would reach the views and exit 0 under --json, so a success without the `{ data }` envelope is
+ * an error, as in the attribution resource.
+ */
+const envelope = async (pending, isData = isObject) => {
+    const body = await pending;
+    if (!isData(dataOf(body))) {
+        throw new ApiError({
+            code: 'malformed_response',
+            details: body,
+            message: 'The Developer API answered with a success status but not with its response envelope, '
+                + 'so the answer was cut short or came from something in between. Nothing was read.',
+            status: 200,
+        });
+    }
+    return body;
+};
+/**
+ * Every path of the analytics of an app in one place. The catalog and the values are GETs and keep the
+ * transport's retry. The six operations are POSTs that run analytics queries under the rate limits of each route
+ * (2 requests per second per app and 360 per minute for all callers together, as the Export API): sent once,
+ * never retried, and a 429 reaches the caller with the server's wait.
+ *
+ * The validating methods are async on purpose — a broken rule then arrives as a rejected promise, like a
+ * network failure, and one await covers both.
+ */
+export const analytics = (http) => ({
+    catalog: (appId) => envelope(http.get(`${base(appId)}/catalog`)),
+    chart: async (input) => {
+        assertValid(validateChart(input));
+        return envelope(http.post(`${base(input.appId)}/metrics`, toChartRequest(input), { idempotent: false }), hasSegments);
+    },
+    cohort: async (input) => {
+        assertValid(validateCohort(input));
+        return envelope(http.post(`${base(input.appId)}/cohort`, toCohortRequest(input), { idempotent: false }), hasSegments);
+    },
+    conversion: async (input) => {
+        assertValid(validateConversion(input));
+        return envelope(http.post(`${base(input.appId)}/conversion`, toConversionRequest(input), { idempotent: false }), hasSegments);
+    },
+    funnel: async (input) => {
+        assertValid(validateFunnel(input));
+        return envelope(http.post(`${base(input.appId)}/funnel`, toFunnelRequest(input), { idempotent: false }), hasSegments);
+    },
+    ltv: async (input) => {
+        assertValid(validateLtv(input));
+        return envelope(http.post(`${base(input.appId)}/ltv`, toLtvRequest(input), { idempotent: false }), hasSegments);
+    },
+    retention: async (input) => {
+        assertValid(validateRetention(input));
+        return envelope(http.post(`${base(input.appId)}/retention`, toRetentionRequest(input), { idempotent: false }), hasSegments);
+    },
+    values: async (input) => {
+        assertValid(validateFilterValues(input));
+        return envelope(http.get(`${base(input.appId)}/values`, { query: { dimension: input.dimension } }));
+    },
+});

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

@@ -0,0 +1,32 @@
+import type { AnalyticsData, AnalyticsMeta, AnalyticsResponse, AnalyticsSegment } from './model.js';
+import type { AnalyticsQueryInput, GroupingInput, GroupingRequest, QueryRequest } from './query.js';
+import type { Issue } from '../../core/errors.js';
+export type RetentionInput = AnalyticsQueryInput & Pick<GroupingInput, 'groupBy'> & {
+    /** Count from the trial instead of from the first paid period. */
+    useTrial?: boolean | undefined;
+};
+type RetentionRequest = Pick<GroupingRequest, 'segmentation'> & QueryRequest & {
+    use_trial?: boolean;
+};
+/** One retention period: `x` is the backend period number. */
+export type RetentionPoint = {
+    title: string;
+    value: number;
+    value_relative: number;
+    x: number;
+};
+/** `value` and `first_value` are the subscribers of the first period. */
+export type RetentionSegment = AnalyticsSegment & {
+    first_value: number;
+    value: number;
+    values: RetentionPoint[];
+};
+export type RetentionData = AnalyticsData<RetentionSegment>;
+export type RetentionMeta = AnalyticsMeta<{
+    segmentation: null | string;
+    use_trial: boolean;
+}>;
+export type RetentionResponse = AnalyticsResponse<RetentionData, RetentionMeta>;
+export declare const validateRetention: (input: RetentionInput) => Issue[];
+export declare const toRetentionRequest: (input: RetentionInput) => RetentionRequest;
+export {};

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

@@ -0,0 +1,6 @@
+import { toGroupingRequest, toQueryRequest, validateQuery } from './query.js';
+export const validateRetention = (input) => validateQuery(input);
+export const toRetentionRequest = (input) => {
+    const body = { ...toQueryRequest(input), ...toGroupingRequest(input) };
+    return input.useTrial === undefined ? body : { ...body, use_trial: input.useTrial };
+};