adapty 0.11.0 → 0.13.0

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

@@ -0,0 +1,20 @@
+import type { Issue } from '../../core/errors.js';
+/** The values one filter takes for an app: what `filters.<dimension>` accepts, and the `key` of its groups. */
+export type FilterValuesInput = {
+    appId: string;
+    /** A filter key, as the catalog `dimensions` lists it; the backend refuses any other. */
+    dimension: string;
+};
+/** `group` is the parent in the dashboard list (the region of a country, ...); null at the top level. */
+export type FilterValue = {
+    group: null | string;
+    label: string;
+    value: string;
+};
+export type FilterValuesResponse = {
+    data: FilterValue[];
+    meta: {
+        dimension: string;
+    };
+};
+export declare const validateFilterValues: (input: FilterValuesInput) => Issue[];

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

@@ -0,0 +1 @@
+export const validateFilterValues = (input) => (input.dimension.trim() === '' ? [{ message: 'must not be empty', path: 'dimension' }] : []);

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

@@ -1,18 +1,24 @@
 import type { AccessLevelsApi } from './access-levels.js';
+import type { AnalyticsApi } from './analytics/index.js';
 import type { AppsApi } from './apps/index.js';
 import type { AuthApi } from './auth/index.js';
 import type { FeedbackApi } from './feedback/index.js';
 import type { MigrationApi } from './migrations/index.js';
+import type { ProductOffersApi } from './product-offers/index.js';
 import type { Clock } from '../core/clock.js';
 import type { RetryAttempt } from '../core/http/index.js';
+export { periodTypes, periodUnits, revenueBases, validateChart, validateCohort, validateConversion, validateFilterValues, validateFunnel, validateLtv, validateRetention, } from './analytics/index.js';
 export { platforms } from './apps/index.js';
+export { offerTypes } from './product-offers/index.js';
 export { developerErrorParser } from './errors.js';
 export { sentiments } from './feedback/index.js';
 export type { AccessLevel, AccessLevelList, AccessLevelsApi } from './access-levels.js';
+export type { AnalyticsFilter, AnalyticsSegment, CatalogChart, CatalogOperation, CatalogOption, CatalogResponse, CatalogSegmentation, ChartInput, ChartResponse, CohortInput, CohortResponse, ConversionInput, ConversionResponse, FilterValue, FilterValuesInput, FilterValuesResponse, FunnelInput, FunnelResponse, LtvInput, LtvResponse, PeriodUnit, RetentionInput, RetentionResponse, } from './analytics/index.js';
 export type { AppDetail, AppsApi, AppSummary, CreateAppInput, UpdateAppInput } from './apps/index.js';
 export type { AuthApi, AuthUser, IssuedToken } from './auth/index.js';
 export type { FeedbackApi, SendFeedbackInput, Sentiment } from './feedback/index.js';
 export type { Action, ActionKind, AvailableFlow, CreateMigrationInput, Envelope, Issue, JsonSchema, Migration, MigrationApi, MigrationList, MigrationState, Progress, ResourceRef, Step, StepStatus, WaitOptions, WizardError, } from './migrations/index.js';
+export type { CreateProductOfferInput, OfferType, ProductOffer, ProductOffersApi, StoreOffer, UpdateProductOfferInput, } from './product-offers/index.js';
 export type { PageParams, Paginated, Pagination } from './pagination.js';
 /** Exported because the adapter compares the resolved URL with it and warns when they differ. */
 export declare const DEFAULT_ADAPTY_API_URL = "https://api-admin.adapty.io/api/v1/developer";
@@ -36,10 +42,12 @@ export type AdaptyOptions = {
 };
 export type Adapty = {
     accessLevels: AccessLevelsApi;
+    analytics: AnalyticsApi;
     apps: AppsApi;
     auth: AuthApi;
     feedback: FeedbackApi;
     migrations: MigrationApi;
+    productOffers: ProductOffersApi;
 };
 /** The assembly point of the developer API: one transport, resources on top of it. */
 export declare const createAdapty: (options?: AdaptyOptions) => Adapty;

package/dist/sdk/adapty/index.js

@@ -1,12 +1,16 @@
 import { systemClock } from '../core/clock.js';
 import { createHttp } from '../core/http/index.js';
 import { accessLevels } from './access-levels.js';
+import { analytics } from './analytics/index.js';
 import { apps } from './apps/index.js';
 import { auth } from './auth/index.js';
 import { developerErrorParser } from './errors.js';
 import { feedback } from './feedback/index.js';
 import { migrations } from './migrations/index.js';
+import { productOffers } from './product-offers/index.js';
+export { periodTypes, periodUnits, revenueBases, validateChart, validateCohort, validateConversion, validateFilterValues, validateFunnel, validateLtv, validateRetention, } from './analytics/index.js';
 export { platforms } from './apps/index.js';
+export { offerTypes } from './product-offers/index.js';
 export { developerErrorParser } from './errors.js';
 export { sentiments } from './feedback/index.js';
 /** Exported because the adapter compares the resolved URL with it and warns when they differ. */
@@ -46,11 +50,13 @@ export const createAdapty = (options = {}) => {
     const wizard = createHttp({ ...transport, trailingSlash: false });
     return {
         accessLevels: accessLevels(http),
+        analytics: analytics(http),
         apps: apps(http),
         auth: auth(http),
         feedback: feedback(http),
         // The clock is a dependency here too, not only in the transport: `waitFor` sleeps
         // between polls, and a test must be able to do that instantly.
         migrations: migrations(wizard, options.clock ?? systemClock),
+        productOffers: productOffers(http),
     };
 };

package/dist/sdk/adapty/product-offers/create.d.ts

@@ -0,0 +1,5 @@
+import type { OfferWrite } from './model.js';
+import type { Issue } from '../../core/errors.js';
+export type CreateProductOfferInput = OfferWrite;
+/** A list of problems, knowing nothing about flags or the network. A path names an input field. */
+export declare const validateCreateProductOffer: (input: CreateProductOfferInput) => Issue[];

package/dist/sdk/adapty/product-offers/create.js

@@ -0,0 +1,12 @@
+import { hasStoreId, winBackIssues } from './model.js';
+/** A list of problems, knowing nothing about flags or the network. A path names an input field. */
+export const validateCreateProductOffer = (input) => {
+    const issues = [];
+    if (input.title.trim() === '') {
+        issues.push({ message: 'must not be empty', path: 'title' });
+    }
+    if (!hasStoreId(input)) {
+        issues.push({ fields: ['iosOfferId', 'androidOfferId'], message: 'pass {iosOfferId}, {androidOfferId} or both' });
+    }
+    return [...issues, ...winBackIssues(input)];
+};

package/dist/sdk/adapty/product-offers/index.d.ts

@@ -0,0 +1,9 @@
+/** The door of the product-offers resource: re-exports only, no code of its own. */
+export { offerTypes } from './model.js';
+export { validateCreateProductOffer } from './create.js';
+export { productOffers } from './resource.js';
+export { validateUpdateProductOffer } from './update.js';
+export type { OfferType, ProductOffer, StoreOffer } from './model.js';
+export type { CreateProductOfferInput } from './create.js';
+export type { ProductOffersApi } from './resource.js';
+export type { UpdateProductOfferInput } from './update.js';

package/dist/sdk/adapty/product-offers/index.js

@@ -0,0 +1,5 @@
+/** The door of the product-offers resource: re-exports only, no code of its own. */
+export { offerTypes } from './model.js';
+export { validateCreateProductOffer } from './create.js';
+export { productOffers } from './resource.js';
+export { validateUpdateProductOffer } from './update.js';

package/dist/sdk/adapty/product-offers/model.d.ts

@@ -0,0 +1,48 @@
+/**
+ * What every operation of the resource shares: the offer as the server sends it, and the type
+ * vocabulary. Answers pass through exactly as they arrive, in snake_case, which is what --json prints.
+ */
+import type { Issue } from '../../core/errors.js';
+/** The types a write accepts, as the server names them. */
+export declare const offerTypes: readonly ["promotional", "win_back"];
+export type OfferType = (typeof offerTypes)[number];
+export type StoreOffer = {
+    offer_id: string;
+};
+export type ProductOffer = {
+    /** Null when the offer has no fixed duration. */
+    duration: null | string;
+    id: string;
+    /** Not the OfferType union: the server also answers `introductory`, which a write refuses. */
+    offer_type: string;
+    product_id: string;
+    /** Keyed as the server stored it: `app_store`, `play_store`, and any other key it may hold. */
+    store_offers: Record<string, StoreOffer>;
+    title: string;
+};
+/** The fields of a write. */
+export type OfferWrite = {
+    androidOfferId?: string | undefined;
+    iosOfferId?: string | undefined;
+    offerType: OfferType;
+    title: string;
+};
+/** An update merged onto the stored offer, before the rules have checked its type. */
+export type OfferDraft = Omit<OfferWrite, 'offerType'> & {
+    offerType: string;
+};
+export declare const isOfferType: (value: string) => value is OfferType;
+/** Trimmed, and a blank id is not an id: `--ios-offer-id ""` counts as absent. */
+export declare const storeId: (value: string | undefined) => string | undefined;
+export declare const hasStoreId: (write: OfferDraft) => boolean;
+/** Google Play has no win-back offers: the server refuses a win_back with an android id. */
+export declare const winBackIssues: (write: OfferDraft) => Issue[];
+type OfferWriteRequest = {
+    android_offer_id?: string;
+    ios_offer_id?: string;
+    offer_type: string;
+    title: string;
+};
+/** The body of create and update alike: the server replaces the whole offer. Blank ids are left out. */
+export declare const toWriteRequest: (write: OfferDraft) => OfferWriteRequest;
+export {};

package/dist/sdk/adapty/product-offers/model.js

@@ -0,0 +1,30 @@
+/**
+ * What every operation of the resource shares: the offer as the server sends it, and the type
+ * vocabulary. Answers pass through exactly as they arrive, in snake_case, which is what --json prints.
+ */
+/** The types a write accepts, as the server names them. */
+export const offerTypes = ['promotional', 'win_back'];
+export const isOfferType = (value) => offerTypes.includes(value);
+/** Trimmed, and a blank id is not an id: `--ios-offer-id ""` counts as absent. */
+export const storeId = (value) => {
+    const trimmed = value?.trim();
+    return trimmed === '' ? undefined : trimmed;
+};
+export const hasStoreId = (write) => storeId(write.iosOfferId) !== undefined || storeId(write.androidOfferId) !== undefined;
+/** Google Play has no win-back offers: the server refuses a win_back with an android id. */
+export const winBackIssues = (write) => (write.offerType === 'win_back' && storeId(write.androidOfferId) !== undefined
+    ? [{ message: 'a win_back offer takes only an App Store offer id', path: 'androidOfferId' }]
+    : []);
+/** The body of create and update alike: the server replaces the whole offer. Blank ids are left out. */
+export const toWriteRequest = (write) => {
+    const body = { offer_type: write.offerType, title: write.title };
+    const ios = storeId(write.iosOfferId);
+    const android = storeId(write.androidOfferId);
+    if (ios !== undefined) {
+        body.ios_offer_id = ios;
+    }
+    if (android !== undefined) {
+        body.android_offer_id = android;
+    }
+    return body;
+};

package/dist/sdk/adapty/product-offers/resource.d.ts

@@ -0,0 +1,21 @@
+import type { CreateProductOfferInput } from './create.js';
+import type { ProductOffer } from './model.js';
+import type { UpdateProductOfferInput } from './update.js';
+import type { Http } from '../../core/http/index.js';
+import type { Paginated } from '../pagination.js';
+/**
+ * Offers are listed and created under a product and read and changed by their own id under the app:
+ * the two path shapes the server routes. There is no delete: offers are deleted in the dashboard only.
+ *
+ * The validating methods are async on purpose: a broken rule arrives as a rejected promise, like a
+ * network failure.
+ */
+export declare const productOffers: (http: Http) => {
+    get: (appId: string, offerId: string) => Promise<ProductOffer>;
+    /** The server answers every offer of the product on one page. */
+    list: (appId: string, productId: string) => Promise<Paginated<ProductOffer>>;
+    create: (appId: string, productId: string, input: CreateProductOfferInput) => Promise<ProductOffer>;
+    /** A full replace on the server, so this reads the stored offer and sends it back merged. */
+    update: (appId: string, offerId: string, input: UpdateProductOfferInput) => Promise<ProductOffer>;
+};
+export type ProductOffersApi = ReturnType<typeof productOffers>;

package/dist/sdk/adapty/product-offers/resource.js

@@ -0,0 +1,28 @@
+import { assertValid } from '../../core/validation.js';
+import { validateCreateProductOffer } from './create.js';
+import { toWriteRequest } from './model.js';
+import { mergeProductOffer, validateMergedProductOffer, validateUpdateProductOffer } from './update.js';
+/**
+ * Offers are listed and created under a product and read and changed by their own id under the app:
+ * the two path shapes the server routes. There is no delete: offers are deleted in the dashboard only.
+ *
+ * The validating methods are async on purpose: a broken rule arrives as a rejected promise, like a
+ * network failure.
+ */
+export const productOffers = (http) => ({
+    get: (appId, offerId) => http.get(`/apps/${appId}/offers/${offerId}`),
+    /** The server answers every offer of the product on one page. */
+    list: (appId, productId) => http.get(`/apps/${appId}/products/${productId}/offers`),
+    create: async (appId, productId, input) => {
+        assertValid(validateCreateProductOffer(input));
+        return http.post(`/apps/${appId}/products/${productId}/offers`, toWriteRequest(input));
+    },
+    /** A full replace on the server, so this reads the stored offer and sends it back merged. */
+    update: async (appId, offerId, input) => {
+        assertValid(validateUpdateProductOffer(input));
+        const stored = await http.get(`/apps/${appId}/offers/${offerId}`);
+        const merged = mergeProductOffer(stored, input);
+        assertValid(validateMergedProductOffer(stored, input, merged));
+        return http.put(`/apps/${appId}/offers/${offerId}`, toWriteRequest(merged));
+    },
+});

package/dist/sdk/adapty/product-offers/update.d.ts

@@ -0,0 +1,19 @@
+import type { OfferDraft, OfferType, ProductOffer } from './model.js';
+import type { Issue } from '../../core/errors.js';
+/** A store id is replaced by a string and removed by null; undefined or blank keeps what is stored. */
+export type UpdateProductOfferInput = {
+    androidOfferId?: null | string | undefined;
+    iosOfferId?: null | string | undefined;
+    offerType?: OfferType | undefined;
+    title?: string | undefined;
+};
+/** Rules that need no stored offer, so they run before the first request. */
+export declare const validateUpdateProductOffer: (input: UpdateProductOfferInput) => Issue[];
+/** The offer after the update: the server replaces the whole offer, so untouched fields come from the stored one. */
+export declare const mergeProductOffer: (offer: ProductOffer, input: UpdateProductOfferInput) => OfferDraft;
+/**
+ * Rules on the stored offer and the merged one, so they run after the read and before the write. The
+ * write carries only `app_store` and `play_store`, so an offer with any other store key is refused
+ * rather than losing that side to the replace.
+ */
+export declare const validateMergedProductOffer: (offer: ProductOffer, input: UpdateProductOfferInput, merged: OfferDraft) => Issue[];

package/dist/sdk/adapty/product-offers/update.js

@@ -0,0 +1,42 @@
+import { hasStoreId, isOfferType, storeId, winBackIssues } from './model.js';
+const given = (value) => (value === null ? null : storeId(value));
+/** Rules that need no stored offer, so they run before the first request. */
+export const validateUpdateProductOffer = (input) => {
+    const fields = [input.title, input.offerType, given(input.iosOfferId), given(input.androidOfferId)];
+    if (fields.every(value => value === undefined)) {
+        return [{ message: 'nothing to update: pass a title, a type or a store offer id' }];
+    }
+    if (input.title?.trim() === '') {
+        return [{ message: 'must not be empty', path: 'title' }];
+    }
+    return [];
+};
+const pick = (value, stored) => (value === undefined ? stored : (value ?? undefined));
+/** The offer after the update: the server replaces the whole offer, so untouched fields come from the stored one. */
+export const mergeProductOffer = (offer, input) => ({
+    androidOfferId: pick(given(input.androidOfferId), storeId(offer.store_offers.play_store?.offer_id)),
+    iosOfferId: pick(given(input.iosOfferId), storeId(offer.store_offers.app_store?.offer_id)),
+    offerType: input.offerType ?? offer.offer_type,
+    title: input.title ?? offer.title,
+});
+/**
+ * Rules on the stored offer and the merged one, so they run after the read and before the write. The
+ * write carries only `app_store` and `play_store`, so an offer with any other store key is refused
+ * rather than losing that side to the replace.
+ */
+export const validateMergedProductOffer = (offer, input, merged) => {
+    if (!isOfferType(offer.offer_type)) {
+        return [{ message: `${offer.offer_type} offers are read-only` }];
+    }
+    const otherKeys = Object.keys(offer.store_offers).filter(key => key !== 'app_store' && key !== 'play_store');
+    if (otherKeys.length > 0) {
+        return [{ message: `this offer has store sides the update would drop (${otherKeys.join(', ')}): edit it in the dashboard` }];
+    }
+    if (!hasStoreId(merged)) {
+        return [{ message: 'an offer needs at least one store offer id: delete it in the dashboard instead of clearing both' }];
+    }
+    if (given(input.androidOfferId) === undefined && winBackIssues(merged).length > 0) {
+        return [{ message: 'a win_back offer takes only an App Store offer id: clear the stored Google Play one' }];
+    }
+    return winBackIssues(merged);
+};

package/dist/sdk/attribution/index.d.ts

@@ -2,7 +2,7 @@ import type { AttributionApi } from './resource.js';
 import type { Clock } from '../core/clock.js';
 import type { RetryAttempt } from '../core/http/index.js';
 export { attributionErrorParser } from './errors.js';
-export { granularities, ISO_DATE, reportGroupBy, revenueBases, sortDirections, validateReport } from './report.js';
+export { granularities, reportGroupBy, revenueBases, sortDirections, validateReport } from './report.js';
 export { validateValues } from './values.js';
 export type { Dimension, DimensionCatalog, DimensionIdentity, Metric, MetricCatalog, MetricUnit, ReportLimits, } from './catalog.js';
 export type { Granularity, ReportData, ReportFilter, ReportGroupBy, ReportInput, ReportMeta, ReportRow, ReportSort, RevenueBasis, SortDirection, } from './report.js';

package/dist/sdk/attribution/index.js

@@ -3,7 +3,7 @@ import { createHttp, defaultRetryPolicy, defaultShouldRetry } from '../core/http
 import { attributionErrorParser } from './errors.js';
 import { attribution } from './resource.js';
 export { attributionErrorParser } from './errors.js';
-export { granularities, ISO_DATE, reportGroupBy, revenueBases, sortDirections, validateReport } from './report.js';
+export { granularities, reportGroupBy, revenueBases, sortDirections, validateReport } from './report.js';
 export { validateValues } from './values.js';
 /** Exported because the adapter compares the resolved URL with it and warns when they differ. */
 export const DEFAULT_ATTRIBUTION_API_URL = 'https://api-ua.adapty.io/api/v1/cli';

package/dist/sdk/attribution/report.d.ts

@@ -57,8 +57,6 @@ export type ReportMeta = {
     /** The query as the backend resolved it: timezone, currency and defaults filled in. */
     query: Record<string, unknown>;
 };
-/** The `YYYY-MM-DD` shape alone, shared with the adapter's date flag parser. */
-export declare const ISO_DATE: RegExp;
 /** Shared with values: both read a day range, and both are refused the same way. */
 export declare const validateDateRange: (input: {
     dateFrom: string;

package/dist/sdk/attribution/report.js

@@ -1,35 +1,11 @@
+import { validateDayRange } from '../core/dates.js';
 /** In the order the backend documents them, so a flag's help reads the same way. */
 export const reportGroupBy = ['date', 'campaign', 'adset', 'ad', 'keyword', 'channel', 'country', 'store'];
 export const granularities = ['day', 'week', 'month', 'quarter', 'year'];
 export const revenueBases = ['gross', 'proceeds', 'net'];
 export const sortDirections = ['asc', 'desc'];
-/** The `YYYY-MM-DD` shape alone, shared with the adapter's date flag parser. */
-export const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
-/** The shape alone lets 2026-02-30 through; a round trip through Date does not. */
-const isIsoDate = (value) => {
-    if (!ISO_DATE.test(value)) {
-        return false;
-    }
-    const date = new Date(`${value}T00:00:00Z`);
-    return !Number.isNaN(date.getTime()) && date.toISOString().startsWith(value);
-};
 /** Shared with values: both read a day range, and both are refused the same way. */
-export const validateDateRange = (input) => {
-    const issues = [];
-    const fromValid = isIsoDate(input.dateFrom);
-    const toValid = isIsoDate(input.dateTo);
-    if (!fromValid) {
-        issues.push({ message: 'must be a date in YYYY-MM-DD form', path: 'dateFrom' });
-    }
-    if (!toValid) {
-        issues.push({ message: 'must be a date in YYYY-MM-DD form', path: 'dateTo' });
-    }
-    // ISO days order as strings, but only two real days are worth comparing
-    if (fromValid && toValid && input.dateTo < input.dateFrom) {
-        issues.push({ message: 'must not be before the start date', path: 'dateTo' });
-    }
-    return issues;
-};
+export const validateDateRange = (input) => validateDayRange(input.dateFrom, input.dateTo, { from: 'dateFrom', to: 'dateTo' });
 /**
  * The rules a report can break without asking the server. Which metric and dimension names exist
  * is the catalog's knowledge, so the backend checks those. An Issue path names an input field

package/dist/sdk/core/dates.d.ts

@@ -0,0 +1,15 @@
+import type { Issue } from './errors.js';
+/**
+ * Days as the backends take them: `YYYY-MM-DD`, an inclusive range of two. Shared by every product that
+ * reads a day range, so a range is checked, and refused, in the same words everywhere.
+ */
+/** The `YYYY-MM-DD` shape alone, shared with the adapter's date flag parser. */
+export declare const ISO_DATE: RegExp;
+/**
+ * Both ends real days, the end not before the start. `paths` names the two input fields, so the adapter
+ * can name the two flags the user typed.
+ */
+export declare const validateDayRange: (from: string, to: string, paths: {
+    from: string;
+    to: string;
+}) => Issue[];

package/dist/sdk/core/dates.js

@@ -0,0 +1,34 @@
+/**
+ * Days as the backends take them: `YYYY-MM-DD`, an inclusive range of two. Shared by every product that
+ * reads a day range, so a range is checked, and refused, in the same words everywhere.
+ */
+/** The `YYYY-MM-DD` shape alone, shared with the adapter's date flag parser. */
+export const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+/** The shape alone lets 2026-02-30 through; a round trip through Date does not. */
+const isIsoDate = (value) => {
+    if (!ISO_DATE.test(value)) {
+        return false;
+    }
+    const date = new Date(`${value}T00:00:00Z`);
+    return !Number.isNaN(date.getTime()) && date.toISOString().startsWith(value);
+};
+/**
+ * Both ends real days, the end not before the start. `paths` names the two input fields, so the adapter
+ * can name the two flags the user typed.
+ */
+export const validateDayRange = (from, to, paths) => {
+    const issues = [];
+    const fromValid = isIsoDate(from);
+    const toValid = isIsoDate(to);
+    if (!fromValid) {
+        issues.push({ message: 'must be a date in YYYY-MM-DD form', path: paths.from });
+    }
+    if (!toValid) {
+        issues.push({ message: 'must be a date in YYYY-MM-DD form', path: paths.to });
+    }
+    // ISO days order as strings, but only two real days are worth comparing
+    if (fromValid && toValid && to < from) {
+        issues.push({ message: 'must not be before the start date', path: paths.to });
+    }
+    return issues;
+};

package/dist/sdk/core/errors.d.ts

@@ -44,6 +44,9 @@ export declare class CancelledError extends SdkError {
     constructor();
 }
 export type Issue = {
+    /** The other input fields that `message` names, each written there as `{fieldName}`. */
+    fields?: readonly string[] | undefined;
+    /** Plain words; another input field appears as `{fieldName}`, listed in `fields`, for the adapter to write. */
     message: string;
     /** The input field the problem belongs to. No path: the input as a whole is wrong. */
     path?: string | undefined;