adapty 0.8.4 → 0.8.6

package/dist/lib/output.js

@@ -3,10 +3,12 @@ function formatLabel(snakeKey) {
     return snakeKey
         .split('_')
         .map((w) => {
-        if (w === 'ids')
+        if (w === 'ids') {
             return 'IDs';
-        if (UPPER_WORDS.has(w))
+        }
+        if (UPPER_WORDS.has(w)) {
             return w.toUpperCase();
+        }
         return w.charAt(0).toUpperCase() + w.slice(1);
     })
         .join(' ');
@@ -18,19 +20,22 @@ function renderArrayItems(items, indent) {
     const childIndent = indent + '  ';
     const lines = [];
     for (const item of items) {
-        if (item === undefined || item === null)
+        if (item === undefined || item === null) {
             continue;
+        }
         if (Array.isArray(item)) {
             lines.push(...renderArrayItems(item, childIndent));
         }
         else if (isScalar(item)) {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string -- FIXME if you see this
             lines.push(`${indent}- ${String(item)}`);
         }
         else {
-            const rendered = renderObject(item, childIndent);
-            if (rendered.length === 0)
+            const [head, ...rest] = renderObject(item, childIndent);
+            if (head === undefined) {
                 continue;
-            lines.push(`${indent}- ${rendered[0].slice(childIndent.length)}`, ...rendered.slice(1));
+            }
+            lines.push(`${indent}- ${head.slice(childIndent.length)}`, ...rest);
         }
     }
     return lines;
@@ -38,13 +43,15 @@ function renderArrayItems(items, indent) {
 function renderObject(data, indent) {
     const lines = [];
     for (const [key, value] of Object.entries(data)) {
-        if (value === undefined || value === null)
+        if (value === undefined || value === null) {
             continue;
+        }
         const label = `${indent}${formatLabel(key)}:`;
         if (Array.isArray(value)) {
-            if (value.length === 0)
+            if (value.length === 0) {
                 continue;
-            if (value.every((v) => isScalar(v))) {
+            }
+            if (value.every(v => isScalar(v))) {
                 lines.push(`${label} ${value.map(String).join(', ')}`);
             }
             else {
@@ -52,25 +59,29 @@ function renderObject(data, indent) {
             }
         }
         else if (isScalar(value)) {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string -- FIXME if you see this
             lines.push(`${label} ${String(value)}`);
         }
         else {
             const nested = renderObject(value, indent + '  ');
-            if (nested.length > 0)
+            if (nested.length > 0) {
                 lines.push(label, ...nested);
+            }
         }
     }
     return lines;
 }
 export function printResponse(data, log) {
-    for (const line of renderObject(data, ''))
+    for (const line of renderObject(data, '')) {
         log(line);
+    }
 }
 export function printList(items, log, pagination) {
     for (const [i, item] of items.entries()) {
         printResponse(item, log);
-        if (i < items.length - 1)
+        if (i < items.length - 1) {
             log('---');
+        }
     }
     if (pagination) {
         log('');

package/dist/lib/preview.d.ts

@@ -5,10 +5,10 @@ export declare const DEFAULT_DEVICE_ID = "iphone-14";
 export declare const ORIENTATIONS: readonly ["landscape", "portrait"];
 export declare const DEFAULT_ORIENTATION = "portrait";
 /** Payload the render page expects. Wire format shared with the UI, hence camelCase. */
-export interface PreviewPayload {
+export type PreviewPayload = {
     flow: Record<string, unknown>;
     remoteConfigs: unknown[];
-}
+};
 /**
  * Accepts either a dashboard-api envelope (`{config, remote_configs, ...}`) or a bare
  * builder config, and returns the shape the render page injects.
@@ -18,10 +18,10 @@ export interface PreviewPayload {
  * rejected there instead — better to say so here, against the file the user named.
  */
 export declare function normalizePreviewConfig(raw: unknown): PreviewPayload;
-export interface RenderTarget {
+export type RenderTarget = {
     device: string;
     orientation: string;
     /** Omitted lets the render page fall back to the flow's first screen. */
-    screen?: string;
-}
+    screen?: string | undefined;
+};
 export declare function buildRenderUrl(target: RenderTarget, payload: PreviewPayload): string;

package/dist/lib/preview.js

@@ -39,8 +39,9 @@ function encodeConfigFragment(payload) {
 }
 export function buildRenderUrl(target, payload) {
     const url = appUrl(PREVIEW_PATH);
-    if (target.screen)
+    if (target.screen) {
         url.searchParams.set('screen', target.screen);
+    }
     url.searchParams.set('device', target.device);
     url.searchParams.set('orientation', target.orientation);
     url.hash = `config=${encodeConfigFragment(payload)}`;

package/dist/sdk/adapty/access-levels.d.ts

@@ -0,0 +1,15 @@
+import type { Http } from '../core/http/index.js';
+export type AccessLevel = {
+    id: string;
+    sdk_id: string;
+    title: null | string;
+};
+/** Not paginated: this endpoint answers with a bare `items` list, and may omit it entirely. */
+export type AccessLevelList = {
+    items?: AccessLevel[];
+};
+/** Only the read `apps create` needs; the rest arrives with the access-levels commands. */
+export declare const accessLevels: (http: Http) => {
+    list: (appId: string) => Promise<AccessLevelList>;
+};
+export type AccessLevelsApi = ReturnType<typeof accessLevels>;

package/dist/sdk/adapty/access-levels.js

@@ -0,0 +1,4 @@
+/** Only the read `apps create` needs; the rest arrives with the access-levels commands. */
+export const accessLevels = (http) => ({
+    list: (appId) => http.get(`/apps/${appId}/access-levels`),
+});

package/dist/sdk/adapty/apps/create.d.ts

@@ -0,0 +1,26 @@
+import type { Platform } from './model.js';
+import type { Issue } from '../../core/errors.js';
+export type CreateAppInput = {
+    appleBundleId?: string | undefined;
+    googleBundleId?: string | undefined;
+    platforms: readonly Platform[];
+    title: string;
+};
+type CreateAppRequest = {
+    apple_bundle_id?: string;
+    google_bundle_id?: string;
+    platforms: Platform[];
+    title: string;
+};
+/**
+ * The business rules of creating an app: a pure function returning a list of problems, knowing
+ * nothing about flags or the network. An Issue path names an input field (camelCase) and the
+ * adapter turns it into the flag the user typed (src/cli/errors.ts).
+ *
+ * A list instead of a throw, so a table test walks the rules without an environment and the user
+ * sees every problem at once.
+ */
+export declare const validateCreateApp: (input: CreateAppInput) => Issue[];
+/** An absent field is left out of the body: the server tells "not given" from "set to empty". */
+export declare const toCreateRequest: (input: CreateAppInput) => CreateAppRequest;
+export {};

package/dist/sdk/adapty/apps/create.js

@@ -0,0 +1,36 @@
+/**
+ * The business rules of creating an app: a pure function returning a list of problems, knowing
+ * nothing about flags or the network. An Issue path names an input field (camelCase) and the
+ * adapter turns it into the flag the user typed (src/cli/errors.ts).
+ *
+ * A list instead of a throw, so a table test walks the rules without an environment and the user
+ * sees every problem at once.
+ */
+export const validateCreateApp = (input) => {
+    const issues = [];
+    if (input.title.trim() === '') {
+        issues.push({ message: 'must not be empty', path: 'title' });
+    }
+    if (input.platforms.length === 0) {
+        issues.push({ message: 'at least one platform is required', path: 'platform' });
+    }
+    // An empty string counts as missing: `--apple-bundle-id ""` is not a bundle id
+    if (input.platforms.includes('ios') && (input.appleBundleId ?? '') === '') {
+        issues.push({ message: 'required when platforms include ios', path: 'appleBundleId' });
+    }
+    if (input.platforms.includes('android') && (input.googleBundleId ?? '') === '') {
+        issues.push({ message: 'required when platforms include android', path: 'googleBundleId' });
+    }
+    return issues;
+};
+/** An absent field is left out of the body: the server tells "not given" from "set to empty". */
+export const toCreateRequest = (input) => {
+    const body = { platforms: [...input.platforms], title: input.title };
+    if (input.appleBundleId !== undefined) {
+        body.apple_bundle_id = input.appleBundleId;
+    }
+    if (input.googleBundleId !== undefined) {
+        body.google_bundle_id = input.googleBundleId;
+    }
+    return body;
+};

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

@@ -0,0 +1,13 @@
+/**
+ * The door of the apps resource: re-exports only, no code of its own. Everything outside the
+ * directory imports from here, which is what lets the files behind it be rearranged. Only what a
+ * consumer uses passes through — the request builders stay private to their operation.
+ */
+export { platforms } from './model.js';
+export { validateCreateApp } from './create.js';
+export { apps } from './resource.js';
+export { validateUpdateApp } from './update.js';
+export type { AppDetail, AppSummary } from './model.js';
+export type { CreateAppInput } from './create.js';
+export type { AppsApi } from './resource.js';
+export type { UpdateAppInput } from './update.js';

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

@@ -0,0 +1,9 @@
+/**
+ * The door of the apps resource: re-exports only, no code of its own. Everything outside the
+ * directory imports from here, which is what lets the files behind it be rearranged. Only what a
+ * consumer uses passes through — the request builders stay private to their operation.
+ */
+export { platforms } from './model.js';
+export { validateCreateApp } from './create.js';
+export { apps } from './resource.js';
+export { validateUpdateApp } from './update.js';

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

@@ -0,0 +1,24 @@
+/**
+ * What every operation of the resource shares: the entity as the server sends it, and the
+ * platform vocabulary. Answers pass through exactly as they arrive, in snake_case — that is what
+ * --json has printed since the first release.
+ *
+ * An input shape is not shared and does not belong here: it is camelCase, it is our API rather
+ * than the server's, and it lives in the file of the operation that takes it.
+ */
+/** In the order the published help lists them, so `--platform` keeps reading `(ios|android)`. */
+export declare const platforms: readonly ["ios", "android"];
+export type Platform = (typeof platforms)[number];
+export type AppSummary = {
+    id: string;
+    sdk_key: null | string;
+    title: string;
+};
+/** What get and update answer with: the summary plus the fields only the detail view carries. */
+export type AppDetail = AppSummary & {
+    apple_bundle_id: null | string;
+    google_bundle_id: null | string;
+    /** Not the Platform union: the server owns this list and may grow it without asking us. */
+    platforms: string[];
+    secret_key: null | string;
+};

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

@@ -0,0 +1,10 @@
+/**
+ * What every operation of the resource shares: the entity as the server sends it, and the
+ * platform vocabulary. Answers pass through exactly as they arrive, in snake_case — that is what
+ * --json has printed since the first release.
+ *
+ * An input shape is not shared and does not belong here: it is camelCase, it is our API rather
+ * than the server's, and it lives in the file of the operation that takes it.
+ */
+/** In the order the published help lists them, so `--platform` keeps reading `(ios|android)`. */
+export const platforms = ['ios', 'android'];

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

@@ -0,0 +1,19 @@
+import type { CreateAppInput } from './create.js';
+import type { AppDetail, AppSummary } from './model.js';
+import type { UpdateAppInput } from './update.js';
+import type { Http } from '../../core/http/index.js';
+import type { PageParams, Paginated } from '../pagination.js';
+/**
+ * Every path of the apps resource in one place, so the endpoints can be read as a list. What each
+ * operation needs of its own — input shape, rules, request body — lives in its own file.
+ *
+ * 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 apps: (http: Http) => {
+    get: (appId: string) => Promise<AppDetail>;
+    list: (params?: PageParams) => Promise<Paginated<AppSummary>>;
+    create: (input: CreateAppInput) => Promise<AppSummary>;
+    update: (appId: string, input: UpdateAppInput) => Promise<AppDetail>;
+};
+export type AppsApi = ReturnType<typeof apps>;

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

@@ -0,0 +1,23 @@
+import { assertValid } from '../../core/validation.js';
+import { pageQuery } from '../pagination.js';
+import { toCreateRequest, validateCreateApp } from './create.js';
+import { toUpdateRequest, validateUpdateApp } from './update.js';
+/**
+ * Every path of the apps resource in one place, so the endpoints can be read as a list. What each
+ * operation needs of its own — input shape, rules, request body — lives in its own file.
+ *
+ * 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 apps = (http) => ({
+    get: (appId) => http.get(`/apps/${appId}`),
+    list: (params) => http.get('/apps', { query: pageQuery(params) }),
+    create: async (input) => {
+        assertValid(validateCreateApp(input));
+        return http.post('/apps', toCreateRequest(input));
+    },
+    update: async (appId, input) => {
+        assertValid(validateUpdateApp(input));
+        return http.put(`/apps/${appId}`, toUpdateRequest(input));
+    },
+});

package/dist/sdk/adapty/apps/update.d.ts

@@ -0,0 +1,16 @@
+import type { Issue } from '../../core/errors.js';
+export type UpdateAppInput = {
+    appleBundleId?: string | undefined;
+    googleBundleId?: string | undefined;
+    title?: string | undefined;
+};
+type UpdateAppRequest = {
+    apple_bundle_id?: string;
+    google_bundle_id?: string;
+    title?: string;
+};
+/** Same contract as the create rule: problems as a list, paths naming input fields. */
+export declare const validateUpdateApp: (input: UpdateAppInput) => Issue[];
+/** An absent field is left out of the body: the server tells "not given" from "set to empty". */
+export declare const toUpdateRequest: (input: UpdateAppInput) => UpdateAppRequest;
+export {};

package/dist/sdk/adapty/apps/update.js

@@ -0,0 +1,25 @@
+/** Same contract as the create rule: problems as a list, paths naming input fields. */
+export const validateUpdateApp = (input) => {
+    const fields = [input.title, input.appleBundleId, input.googleBundleId];
+    if (fields.every(value => value === undefined)) {
+        return [{ message: 'nothing to update: pass a title or a bundle id' }];
+    }
+    if (input.title?.trim() === '') {
+        return [{ message: 'must not be empty', path: 'title' }];
+    }
+    return [];
+};
+/** An absent field is left out of the body: the server tells "not given" from "set to empty". */
+export const toUpdateRequest = (input) => {
+    const body = {};
+    if (input.title !== undefined) {
+        body.title = input.title;
+    }
+    if (input.appleBundleId !== undefined) {
+        body.apple_bundle_id = input.appleBundleId;
+    }
+    if (input.googleBundleId !== undefined) {
+        body.google_bundle_id = input.googleBundleId;
+    }
+    return body;
+};

package/dist/sdk/adapty/auth/device-code.d.ts

@@ -0,0 +1,8 @@
+import type { DeviceCode } from '../../core/auth/device-flow.js';
+import type { Http } from '../../core/http/index.js';
+/**
+ * Step one of the device flow: ask for the code the user will type. The path sits with the
+ * reading of the answer, because here they are one thing — what core's port receives is this
+ * server's response renamed, and the two cannot be understood apart.
+ */
+export declare const requestDeviceCode: (http: Http) => Promise<DeviceCode>;

package/dist/sdk/adapty/auth/device-code.js

@@ -0,0 +1,19 @@
+import { CLIENT_ID } from './model.js';
+/**
+ * Step one of the device flow: ask for the code the user will type. The path sits with the
+ * reading of the answer, because here they are one thing — what core's port receives is this
+ * server's response renamed, and the two cannot be understood apart.
+ */
+export const requestDeviceCode = async (http) => {
+    const response = await http.post('/auth/device', { client_id: CLIENT_ID });
+    return {
+        deviceCode: response.device_code,
+        expiresInSec: response.expires_in,
+        // optional in the protocol; the default is knowledge about this server, so it
+        // belongs here and not in the orchestration
+        intervalSec: response.interval_seconds ?? 5,
+        userCode: response.user_code,
+        verificationUri: response.verification_uri,
+        verificationUriComplete: response.verification_uri_complete,
+    };
+};

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

@@ -0,0 +1,7 @@
+/**
+ * The door of the auth resource: re-exports only, no code of its own. The two device flow steps
+ * are reached through the port `auth()` returns, not imported directly.
+ */
+export { auth } from './resource.js';
+export type { AuthUser, IssuedToken } from './model.js';
+export type { AuthApi } from './resource.js';

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

@@ -0,0 +1,5 @@
+/**
+ * The door of the auth resource: re-exports only, no code of its own. The two device flow steps
+ * are reached through the port `auth()` returns, not imported directly.
+ */
+export { auth } from './resource.js';

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

@@ -0,0 +1,15 @@
+/**
+ * What the auth operations share: the shapes a successful login yields, and the name this client
+ * gives itself. An input shape belongs to its operation, not here.
+ */
+export type AuthUser = {
+    email: string;
+    name: string;
+};
+export type IssuedToken = {
+    accessToken: string;
+    expiresInSec: number;
+    user: AuthUser;
+};
+/** The device flow identifies the client rather than authenticating it: there is no secret. */
+export declare const CLIENT_ID = "adapty-cli";

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

@@ -0,0 +1,6 @@
+/**
+ * What the auth operations share: the shapes a successful login yields, and the name this client
+ * gives itself. An input shape belongs to its operation, not here.
+ */
+/** The device flow identifies the client rather than authenticating it: there is no secret. */
+export const CLIENT_ID = 'adapty-cli';

package/dist/sdk/adapty/auth/poll-token.d.ts

@@ -0,0 +1,8 @@
+import type { IssuedToken } from './model.js';
+import type { PollResult } from '../../core/auth/device-flow.js';
+import type { Http } from '../../core/http/index.js';
+/**
+ * Step two, asked over and over until the user is done: the answer is a token, a state of the
+ * protocol, or a failure — and telling the three apart is the whole of this operation.
+ */
+export declare const pollToken: (http: Http, deviceCode: string) => Promise<PollResult<IssuedToken>>;

package/dist/sdk/adapty/auth/poll-token.js

@@ -0,0 +1,58 @@
+import { ApiError } from '../../core/errors.js';
+import { CLIENT_ID } from './model.js';
+/** A 400 carrying one of these codes is a state of the protocol, not a failure. */
+const pollResultByCode = {
+    access_denied: { status: 'denied' },
+    authorization_pending: { status: 'pending' },
+    expired_token: { status: 'expired' },
+    slow_down: { status: 'slow_down' },
+};
+/** A protocol code as a state, or a real error when the code is not one of the protocol's. */
+const toPollResult = (code, body) => {
+    const result = pollResultByCode[code];
+    if (result === undefined) {
+        throw new ApiError({
+            code,
+            details: body,
+            message: `Unexpected device flow response: ${code}`,
+            status: 200,
+        });
+    }
+    return result;
+};
+/**
+ * Step two, asked over and over until the user is done: the answer is a token, a state of the
+ * protocol, or a failure — and telling the three apart is the whole of this operation.
+ */
+export const pollToken = async (http, deviceCode) => {
+    try {
+        const response = await http.post('/auth/token', {
+            client_id: CLIENT_ID,
+            device_code: deviceCode,
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+        });
+        // A protocol state normally arrives as a 400 and lands in the catch below, but the
+        // shipped CLI's types also anticipate a 200 whose body is { error: <code> }, and
+        // reading only the thrown case would call a pending login authorized.
+        if (!('access_token' in response)) {
+            return toPollResult(response.error, response);
+        }
+        return {
+            status: 'authorized',
+            token: {
+                accessToken: response.access_token,
+                expiresInSec: response.expires_in,
+                user: response.user,
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.code !== undefined) {
+            const result = pollResultByCode[error.code];
+            if (result) {
+                return result;
+            }
+        }
+        throw error;
+    }
+};

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

@@ -0,0 +1,17 @@
+import type { IssuedToken } from './model.js';
+import type { Http } from '../../core/http/index.js';
+/**
+ * The auth resource: core's DeviceAuthApi port filled in by the two device flow steps, plus the
+ * endpoints that only need a path. A missing or stale token surfaces as AuthRequiredError.
+ *
+ * Unlike apps, not every path is listed here: a device flow step is its path and the reading of
+ * its answer together, so each keeps its own. What is left in this file is the shape of the
+ * resource — which port it satisfies, and what else it answers.
+ */
+export declare const auth: (http: Http) => {
+    me: () => Promise<Record<string, unknown>>;
+    revokeToken: (token: string) => Promise<undefined>;
+    pollToken(deviceCode: string): Promise<import("../../core/auth/device-flow.js").PollResult<IssuedToken>>;
+    requestDeviceCode(): Promise<import("../../core/auth/device-flow.js").DeviceCode>;
+};
+export type AuthApi = ReturnType<typeof auth>;

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

@@ -0,0 +1,21 @@
+import { requestDeviceCode } from './device-code.js';
+import { pollToken } from './poll-token.js';
+/**
+ * The auth resource: core's DeviceAuthApi port filled in by the two device flow steps, plus the
+ * endpoints that only need a path. A missing or stale token surfaces as AuthRequiredError.
+ *
+ * Unlike apps, not every path is listed here: a device flow step is its path and the reading of
+ * its answer together, so each keeps its own. What is left in this file is the shape of the
+ * resource — which port it satisfies, and what else it answers.
+ */
+export const auth = (http) => {
+    const deviceAuth = {
+        pollToken: (deviceCode) => pollToken(http, deviceCode),
+        requestDeviceCode: () => requestDeviceCode(http),
+    };
+    return {
+        ...deviceAuth,
+        me: () => http.get('/me'),
+        revokeToken: (token) => http.post('/auth/tokens/revoke', { token }),
+    };
+};

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

@@ -0,0 +1,10 @@
+import type { ErrorParser } from '../core/http/index.js';
+/**
+ * How this service words a rejection: `{ error_code, errors: { field: [message] } }`, sometimes
+ * just `{ error: 'code' }`. Ported from src/lib/errors.ts so a migrated command keeps saying
+ * "apple_bundle_id: already used" instead of "POST /apps failed with HTTP 400".
+ *
+ * Wired once in createAdapty: which shapes a service speaks is product knowledge, and ASA speaks
+ * another — which is why the transport takes the parser as a parameter.
+ */
+export declare const developerErrorParser: ErrorParser;

package/dist/sdk/adapty/errors.js

@@ -0,0 +1,38 @@
+/**
+ * How this service words a rejection: `{ error_code, errors: { field: [message] } }`, sometimes
+ * just `{ error: 'code' }`. Ported from src/lib/errors.ts so a migrated command keeps saying
+ * "apple_bundle_id: already used" instead of "POST /apps failed with HTTP 400".
+ *
+ * Wired once in createAdapty: which shapes a service speaks is product knowledge, and ASA speaks
+ * another — which is why the transport takes the parser as a parameter.
+ */
+export const developerErrorParser = (_status, body) => {
+    if (typeof body !== 'object' || body === null) {
+        return {};
+    }
+    const { error, error_code: errorCode, errors } = body;
+    if (typeof errorCode === 'string' && errorCode !== '') {
+        // The bare code as the fallback message: what the published CLI prints, and still better
+        // than an HTTP status when the server sends no field errors
+        return { code: errorCode, message: fieldMessages(errors) ?? errorCode };
+    }
+    if (typeof error === 'string' && error !== '') {
+        return { code: error, message: error };
+    }
+    return {};
+};
+/** `non_field_errors` is the server's name for "about the request as a whole": printed bare. */
+const fieldMessages = (errors) => {
+    if (typeof errors !== 'object' || errors === null) {
+        return undefined;
+    }
+    const parts = [];
+    for (const [field, messages] of Object.entries(errors)) {
+        for (const message of Array.isArray(messages) ? messages : [messages]) {
+            if (typeof message === 'string') {
+                parts.push(field === 'non_field_errors' ? message : `${field}: ${message}`);
+            }
+        }
+    }
+    return parts.length > 0 ? parts.join('; ') : undefined;
+};

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

@@ -0,0 +1,36 @@
+import type { AccessLevelsApi } from './access-levels.js';
+import type { AppsApi } from './apps/index.js';
+import type { AuthApi } from './auth/index.js';
+import type { Clock } from '../core/clock.js';
+import type { RetryAttempt } from '../core/http/index.js';
+export { platforms } from './apps/index.js';
+export { developerErrorParser } from './errors.js';
+export type { AccessLevel, AccessLevelList, AccessLevelsApi } from './access-levels.js';
+export type { AppDetail, AppsApi, AppSummary, CreateAppInput, UpdateAppInput } from './apps/index.js';
+export type { AuthApi, AuthUser, IssuedToken } from './auth/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";
+/**
+ * Narrower than HttpOptions on purpose: the transport seams (parseError, shouldRetry, the retry
+ * policy, trailingSlash) are product knowledge, and two adapters overriding them would read the
+ * same answers differently. What is left is what a consumer really owns.
+ */
+export type AdaptyOptions = {
+    baseUrl?: string | undefined;
+    clock?: Clock | undefined;
+    fetch?: typeof globalThis.fetch | undefined;
+    onRetry?: ((info: RetryAttempt) => void) | undefined;
+    signal?: AbortSignal | undefined;
+    /** Without a token only auth is usable — that is how login builds the sdk. */
+    token?: string | undefined;
+    /** Comes from the adapter, so server logs can tell the CLI from an MCP server. */
+    userAgent?: string | undefined;
+};
+export type Adapty = {
+    accessLevels: AccessLevelsApi;
+    apps: AppsApi;
+    auth: AuthApi;
+};
+/** The assembly point of the developer API: one transport, resources on top of it. */
+export declare const createAdapty: (options?: AdaptyOptions) => Adapty;