@doany-ai/sdk 0.2.9-alpha.0 → 0.3.0-alpha.0

package/dist/client.js

@@ -13,6 +13,9 @@ import { createAgentsModule } from "./modules/agents.js";
 import { createAiGatewayModule } from "./modules/ai-gateway.js";
 import { createAppLogsModule } from "./modules/app-logs.js";
 import { createUsersModule } from "./modules/users.js";
+import { createContactsModule } from "./modules/contacts.js";
+import { createEventsModule } from "./modules/events.js";
+import { createProjectScope } from "./modules/project.js";
 import { RoomsSocket } from "./utils/socket-utils.js";
 import { createAnalyticsModule } from "./modules/analytics.js";
 /**
@@ -54,7 +57,10 @@ import { createAnalyticsModule } from "./modules/analytics.js";
  */
 export function createClient(config) {
     var _a, _b;
-    const { serverUrl = "https://api.doany.ai", appId, token, serviceToken, requiresAuth = false, appBaseUrl, options, functionsVersion, headers: optionalHeaders, } = config;
+    const { serverUrl = "https://api.doany.ai", appId, token, serviceToken, requiresAuth = false, appBaseUrl, options, functionsVersion, headers: optionalHeaders, projectId, platformToken, operatorUserId, } = config;
+    if (platformToken && !projectId) {
+        throw new Error("createClient({ platformToken }) needs projectId: a platform client names the business it works on");
+    }
     // Normalize appBaseUrl to always be a string (empty if not provided or invalid)
     const normalizedAppBaseUrl = typeof appBaseUrl === "string" ? appBaseUrl : "";
     const socketConfig = {
@@ -83,9 +89,17 @@ export function createClient(config) {
             "Doany-Functions-Version": functionsVersion,
         }
         : headers;
+    // The platform's credential rides on the client's own requests only: not on
+    // function calls, and never on the service-role client, which is the app key's.
+    const platformHeaders = platformToken
+        ? {
+            "x-doany-service-token": platformToken,
+            ...(operatorUserId ? { "x-doany-operator-user-id": operatorUserId } : {}),
+        }
+        : {};
     const axiosClient = createAxiosClient({
         baseURL: `${serverUrl}/api`,
-        headers,
+        headers: { ...headers, ...platformHeaders },
         token,
         onError: options === null || options === void 0 ? void 0 : options.onError,
     });
@@ -120,6 +134,12 @@ export function createClient(config) {
         token: serviceToken,
         interceptResponses: false,
     });
+    // The business the site belongs to, for the /projects/{project_id}/...
+    // modules: as given, or read once from the site's public settings. Each
+    // client reads them with its own credential: a login-gated site refuses the
+    // read without one, and a backend function may hold only the service token.
+    const project = createProjectScope(axiosClient, appId, projectId);
+    const serviceProject = createProjectScope(serviceRoleAxiosClient, appId, projectId);
     const userAuthModule = createAuthModule(axiosClient, functionsAxiosClient, appId, {
         appBaseUrl: normalizedAppBaseUrl,
         serverUrl,
@@ -141,9 +161,14 @@ export function createClient(config) {
             getSocket,
         }),
         integrations: createIntegrationsModule(axiosClient, appId),
-        payments: createPaymentsModule(axiosClient, appId),
-        catalog: createCatalogModule(axiosClient, appId),
-        orders: createOrdersModule(axiosClient, appId),
+        app: project.app,
+        payments: createPaymentsModule(axiosClient, appId, project),
+        catalog: createCatalogModule(axiosClient, appId, project),
+        // A platform client runs on a server for many operators: like the service
+        // role, it keeps no retry state between calls.
+        orders: createOrdersModule(axiosClient, appId, project, { rememberAttempts: !platformToken }),
+        contacts: createContactsModule(axiosClient, project),
+        events: createEventsModule(axiosClient, project),
         connectors: createUserConnectorsModule(axiosClient, appId),
         auth: userAuthModule,
         functions: createFunctionsModule(functionsAxiosClient, appId, {
@@ -167,7 +192,7 @@ export function createClient(config) {
         }),
         aiGateway: createAiGatewayModule({ serverUrl, token, appId }),
         appLogs: createAppLogsModule(axiosClient, appId),
-        users: createUsersModule(axiosClient, appId),
+        users: createUsersModule(axiosClient, appId, project),
         analytics: createAnalyticsModule({
             axiosClient,
             serverUrl,
@@ -202,15 +227,34 @@ export function createClient(config) {
         // actually there, and a function naming its own mode could charge a real
         // card from a preview.
         payments: (() => {
-            const full = createPaymentsModule(serviceRoleAxiosClient, appId);
+            const full = createPaymentsModule(serviceRoleAxiosClient, appId, serviceProject);
             return {
                 getCheckoutSession: full.getCheckoutSession.bind(full),
                 getSubscription: full.getSubscription.bind(full),
                 // Reading the products is not a decision for any browser, and a
                 // fulfilment function often needs what it just sold.
                 products: full.products,
+                // An order's checkout (e.g. a payment link to send) and the payment
+                // records. Not getForOrder: a service caller may not use it
+                // (permissions `payments:get_for_order`); it reads payments with `get`.
+                checkout: full.checkout.bind(full),
+                list: full.list.bind(full),
+                get: full.get.bind(full),
             };
         })(),
+        catalog: createCatalogModule(serviceRoleAxiosClient, appId, serviceProject),
+        orders: createOrdersModule(serviceRoleAxiosClient, appId, serviceProject, { rememberAttempts: false }),
+        contacts: (() => {
+            // `me` is a signed-in account's own contact; the app key has none.
+            const { me: _me, updateMe: _updateMe, ...rest } = createContactsModule(serviceRoleAxiosClient, serviceProject);
+            return rest;
+        })(),
+        events: createEventsModule(serviceRoleAxiosClient, serviceProject),
+        users: (() => {
+            // The invite route requires a signed-in account; the app key alone gets a 401.
+            const { inviteUser: _invite, ...rest } = createUsersModule(serviceRoleAxiosClient, appId, serviceProject);
+            return rest;
+        })(),
         functions: createFunctionsModule(serviceRoleFunctionsAxiosClient, appId, {
             getAuthHeaders: () => {
                 const headers = {};

package/dist/client.types.d.ts

@@ -11,6 +11,10 @@ import type { AgentsModule } from "./modules/agents.types.js";
 import type { AiGatewayModule } from "./modules/ai-gateway.types.js";
 import type { AppLogsModule } from "./modules/app-logs.types.js";
 import type { AnalyticsModule } from "./modules/analytics.types.js";
+import type { ContactsModule } from "./modules/contacts.types.js";
+import type { EventsModule } from "./modules/events.types.js";
+import type { UsersModule } from "./modules/users.types.js";
+import type { AppModule } from "./modules/project.types.js";
 /**
  * Options for creating a Doany client.
  */
@@ -46,6 +50,12 @@ export interface CreateClientConfig {
      * It's the string between `/apps/` and `/editor/`.
      */
     appId: string;
+    /**
+     * The business (project) the app belongs to, for the catalog, orders,
+     * payments, contacts, events and users modules. Optional: left out, the SDK
+     * reads it once from the app's public settings.
+     */
+    projectId?: string;
     /**
      * User authentication token. Used to authenticate as a specific user.
      *
@@ -57,6 +67,18 @@ export interface CreateClientConfig {
      * @internal
      */
     serviceToken?: string;
+    /**
+     * The Doany platform's own credential (the platform website's server,
+     * Annie's tools), sent as `x-doany-service-token` on the client's requests.
+     * Needs `projectId`: a platform client names the business it works on.
+     */
+    platformToken?: string;
+    /**
+     * The platform account a `platformToken` call is made for, sent as
+     * `x-doany-operator-user-id`: it must be allowed on the project, and it is
+     * who the business's history records.
+     */
+    operatorUserId?: string;
     /**
      * Whether authentication is required. If true, redirects to login if not authenticated.
      * @internal
@@ -105,8 +127,16 @@ export interface DoanyClient {
     payments: PaymentsModule;
     /** {@link CatalogModule | Catalog module} for reading what the business offers. */
     catalog: CatalogModule;
-    /** {@link OrdersModule | Orders module} for placing and reading orders. */
+    /** {@link OrdersModule | Orders module} for placing and managing orders. */
     orders: OrdersModule;
+    /** {@link ContactsModule | Contacts module} for the people the business knows. */
+    contacts: ContactsModule;
+    /** {@link EventsModule | Events module} for the business's timeline. */
+    events: EventsModule;
+    /** {@link UsersModule | Users module} for inviting and managing the site's accounts. */
+    users: UsersModule;
+    /** {@link AppModule | App module} for the site's public settings. */
+    app: AppModule;
     /** Cleanup function to disconnect WebSocket connections. Call when you're done with the client. */
     cleanup: () => void;
     /**
@@ -156,11 +186,31 @@ export interface DoanyClient {
          * service-role caller, so the ordinary client cannot resolve a mode and
          * the read fails whatever the function forwards.
          *
-         * Only the reads are here — the two above and the products. There
-         * is no service-role checkout: opening one is a decision that belongs to
-         * the browser that is actually there.
+         * The reads are here — the two above and the products — and, for
+         * orders, `checkout` (e.g. a payment link to send), `list` and `get`.
+         * Not `getForOrder`: a service caller reads payments with `get`.
+         */
+        payments: Pick<PaymentsModule, "getCheckoutSession" | "getSubscription" | "products" | "checkout" | "list" | "get">;
+        /** {@link CatalogModule | Catalog module} with the service credential. */
+        catalog: CatalogModule;
+        /**
+         * {@link OrdersModule | Orders module} with the service credential. Unlike
+         * a page's client, nothing is remembered between calls: pass
+         * `idempotencyKey` to make a retry answer with the first order.
+         */
+        orders: OrdersModule;
+        /**
+         * {@link ContactsModule | Contacts module} with the service credential. No
+         * `me` / `updateMe`: those are a signed-in account's own contact.
+         */
+        contacts: Omit<ContactsModule, "me" | "updateMe">;
+        /** {@link EventsModule | Events module} with the service credential. */
+        events: EventsModule;
+        /**
+         * {@link UsersModule | Users module} with the service credential. No `inviteUser`: an invitation is sent by a
+         * signed-in account (the invite route requires one), not by the app key.
          */
-        payments: Pick<PaymentsModule, "getCheckoutSession" | "getSubscription" | "products">;
+        users: Omit<UsersModule, "inviteUser">;
         /** {@link SsoModule | SSO module} for generating SSO tokens.
          * @internal
          */

package/dist/index.d.ts

@@ -5,15 +5,19 @@ export { createClient, createClientFromRequest, DoanyError, getAccessToken, save
 export type { DoanyClient, CreateClientConfig, CreateClientOptions, DoanyErrorJSON, };
 export * from "./types.js";
 export type { DeleteManyResult, DeleteResult, EntitiesModule, EntityFilterOperators, EntityFilterQuery, EntityFilterValue, EntityHandler, EntityRecord, EntityTypeRegistry, ImportResult, RealtimeEventType, RealtimeEvent, RealtimeCallback, SortField, UpdateManyResult, } from "./modules/entities.types.js";
-export type { AuthModule, LoginResponse, RegisterParams, VerifyOtpParams, ChangePasswordParams, ResetPasswordParams, User, } from "./modules/auth.types.js";
+export type { AuthModule, LoginResponse, LoginSession, RegisterParams, VerifyOtpParams, ChangePasswordParams, ResetPasswordParams, User, } from "./modules/auth.types.js";
 export type { IntegrationsModule, IntegrationEndpointFunction, CoreIntegrations, InvokeLLMParams, GenerateImageParams, GenerateImageResult, UploadFileParams, UploadFileResult, SendEmailParams, SendEmailResult, ExtractDataFromUploadedFileParams, ExtractDataFromUploadedFileResult, UploadPrivateFileParams, UploadPrivateFileResult, CreateFileSignedUrlParams, CreateFileSignedUrlResult, } from "./modules/integrations.types.js";
 export type { FunctionsModule, FunctionName, FunctionNameRegistry, } from "./modules/functions.types.js";
 export type { AgentsModule, AgentName, AgentNameRegistry, AgentConversation, AgentMessage, AgentMessageReasoning, AgentMessageToolCall, AgentMessageUsage, AgentMessageCustomContext, AgentMessageMetadata, CreateConversationParams, } from "./modules/agents.types.js";
 export type { AiGatewayModule, AiGatewayConnection, } from "./modules/ai-gateway.types.js";
 export type { AppLogsModule } from "./modules/app-logs.types.js";
-export type { PaymentsModule, ProductsModule, Product, ProductQuery, ProductSort, CheckoutLineItem, CreateCheckoutParams, CreateCheckoutResult, CreateEmbeddedCheckoutResult, CheckoutSession, SubscriptionState, BillingPortalParams, } from "./modules/payments.types.js";
-export type { CatalogModule, CatalogItem, CatalogVariant, CatalogListParams, } from "./modules/catalog.types.js";
-export type { OrdersModule, Order, OrderItem, OrderBuyer, OrderSummary, OrderStatus, FulfillmentStatus, CreateOrderParams, CreateOrderOptions, CreateOrderResult, OrderListParams, OrderAccessOptions, } from "./modules/orders.types.js";
+export type { PaymentsModule, ProductsModule, Product, ProductQuery, ProductSort, CheckoutLineItem, CreateCheckoutParams, CreateCheckoutResult, CreateEmbeddedCheckoutResult, CheckoutSession, SubscriptionState, BillingPortalParams, OrderCheckoutParams, OrderCheckout, OrderPayments, Payment, PaymentStatus, PaymentListParams, Refund, RefundStatus, } from "./modules/payments.types.js";
+export type { CatalogModule, CatalogItem, CatalogItemKind, CatalogItemStatus, CatalogVariant, CatalogVariantStatus, CatalogListParams, CatalogVariantInput, CreateCatalogItemParams, UpdateCatalogItemParams, UpdateCatalogVariantParams, } from "./modules/catalog.types.js";
+export type { OrdersModule, Order, OrderItem, OrderBuyer, OrderChannel, OrderSummary, OrderStatus, FulfillmentStatus, ShippingAddress, CreateOrderParams, CreateOrderOptions, CreateOrderResult, OrderListParams, OrderAccessOptions, UpdateOrderParams, } from "./modules/orders.types.js";
+export type { ContactsModule, Contact, ContactDetail, ContactSource, ContactUserLink, ContactListParams, CreateContactParams, UpdateContactParams, } from "./modules/contacts.types.js";
+export type { EventsModule, ProjectEvent, EventSubjectType, EventListParams, } from "./modules/events.types.js";
+export type { UsersModule, UserRecord, UserListParams, } from "./modules/users.types.js";
+export type { AppModule, AppPublicSettings, Address, Page, PageParams, VersionInput, CreateOptions, } from "./modules/project.types.js";
 export type { SsoModule, SsoAccessTokenResponse } from "./modules/sso.types.js";
 export type { ConnectorsModule, UserConnectorsModule, ConnectorApiRequest, ConnectorApiResponse, ConnectorProxyRawResponse, } from "./modules/connectors.types.js";
 export type { CustomIntegrationsModule, CustomIntegrationCallParams, CustomIntegrationCallResponse, } from "./modules/custom-integrations.types.js";

package/dist/modules/auth.js

@@ -211,6 +211,12 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
                 otp_code: otpCode,
             });
         },
+        // Exchange the one-time code a sign-in redirect brought back for a token
+        async exchangeLoginCode(code) {
+            return (await axios.post(`/apps/${appId}/auth/session`, {
+                code,
+            }));
+        },
         // Resend an OTP code to the user's email
         resendOtp(email) {
             return axios.post(`/apps/${appId}/auth/resend-otp`, { email });

package/dist/modules/auth.types.d.ts

@@ -42,6 +42,21 @@ export interface LoginResponse {
     /** User information. */
     user: User;
 }
+/** What the session endpoints answer with: the token and the account as the site sees it. */
+export interface LoginSession {
+    access_token: string;
+    user: {
+        id: string;
+        email: string;
+        full_name: string | null;
+        role: string;
+        verified: boolean;
+        created_date: string | null;
+        updated_date: string | null;
+        /** The account's own custom fields. */
+        [field: string]: unknown;
+    };
+}
 /**
  * Payload for user registration.
  */
@@ -514,4 +529,19 @@ export interface AuthModule {
      * ```
      */
     changePassword(params: ChangePasswordParams): Promise<any>;
+    /**
+     * Exchanges the one-time code a sign-in redirect (Google, SSO) brought back
+     * in the URL for an access token. The code is single-use and lives about a
+     * minute. Does not set the token: pass it to `doany.setToken()`.
+     *
+     * @example
+     * ```typescript
+     * const code = new URLSearchParams(window.location.search).get('code');
+     * if (code) {
+     *   const { access_token } = await doany.auth.exchangeLoginCode(code);
+     *   doany.setToken(access_token);
+     * }
+     * ```
+     */
+    exchangeLoginCode(code: string): Promise<LoginSession>;
 }

package/dist/modules/catalog.d.ts

@@ -1,8 +1,9 @@
 import { AxiosInstance } from "axios";
 import { CatalogModule } from "./catalog.types";
+import { ProjectScope } from "./project.js";
 /**
- * Creates the catalog module for the Doany SDK.
+ * Creates the catalog module: `/projects/{project_id}/catalog/...`.
  *
  * @internal
  */
-export declare function createCatalogModule(axios: AxiosInstance, appId: string): CatalogModule;
+export declare function createCatalogModule(axios: AxiosInstance, appId: string, project: ProjectScope): CatalogModule;

package/dist/modules/catalog.js

@@ -1,29 +1,62 @@
+import { idempotencyHeaders, queryOf, seg } from "./project.js";
 /**
- * Creates the catalog module for the Doany SDK.
+ * Creates the catalog module: `/projects/{project_id}/catalog/...`.
  *
  * @internal
  */
-export function createCatalogModule(axios, appId) {
-    const baseURL = `/apps/${appId}/catalog/items`;
+export function createCatalogModule(axios, appId, project) {
+    const items = (suffix = "") => project.path(`/catalog/items${suffix}`);
+    const variants = (suffix) => project.path(`/catalog/variants${suffix}`);
+    const post = async (url, data, headers) => (await axios.request({ method: "POST", url: await url, data, headers }));
     return {
         async list(params = {}) {
-            const query = {};
-            if (params.category)
-                query.category = params.category;
-            if (params.purchasable)
-                query.purchasable = "true";
-            if (params.limit)
-                query.limit = params.limit;
-            if (params.skip)
-                query.skip = params.skip;
-            if (params.sort)
-                query.sort = params.sort;
-            const data = await axios.get(baseURL, { params: query });
-            return data;
-        },
-        async get(itemId) {
-            const data = await axios.get(`${baseURL}/${encodeURIComponent(itemId)}`);
-            return data;
+            // A site lists what it sells unless told otherwise.
+            const query = queryOf({ ...params, app_id: params.app_id === undefined ? appId : params.app_id });
+            return (await axios.get(await items(), { params: query }));
+        },
+        async get(itemId, params = {}) {
+            return (await axios.get(await items(`/${seg(itemId)}`), {
+                params: queryOf(params),
+            }));
+        },
+        create(params, options) {
+            return post(items(), params, idempotencyHeaders(options === null || options === void 0 ? void 0 : options.idempotencyKey));
+        },
+        async update(itemId, params) {
+            return (await axios.patch(await items(`/${seg(itemId)}`), params));
+        },
+        publish(itemId, { version }) {
+            return post(items(`/${seg(itemId)}/publish`), { version });
+        },
+        archive(itemId, { version }) {
+            return post(items(`/${seg(itemId)}/archive`), { version });
+        },
+        restore(itemId, { version }) {
+            return post(items(`/${seg(itemId)}/restore`), { version });
+        },
+        async setDirectPurchase(itemId, { enabled, version }) {
+            return (await axios.put(await items(`/${seg(itemId)}/direct-purchase`), {
+                enabled,
+                version,
+            }));
+        },
+        async delete(itemId) {
+            await axios.delete(await items(`/${seg(itemId)}`));
+        },
+        createVariant(itemId, params, options) {
+            return post(items(`/${seg(itemId)}/variants`), params, idempotencyHeaders(options === null || options === void 0 ? void 0 : options.idempotencyKey));
+        },
+        async updateVariant(variantId, params) {
+            return (await axios.patch(await variants(`/${seg(variantId)}`), params));
+        },
+        archiveVariant(variantId, { version }) {
+            return post(variants(`/${seg(variantId)}/archive`), { version });
+        },
+        restoreVariant(variantId, { version }) {
+            return post(variants(`/${seg(variantId)}/restore`), { version });
+        },
+        async deleteVariant(variantId) {
+            await axios.delete(await variants(`/${seg(variantId)}`));
         },
     };
 }

package/dist/modules/catalog.types.d.ts

@@ -1,9 +1,17 @@
+import type { CreateOptions, Page, PageParams, VersionInput } from "./project.types";
+export type CatalogItemKind = "service" | "physical" | "digital";
+export type CatalogItemStatus = "draft" | "active" | "archived";
+export type CatalogVariantStatus = "active" | "archived";
 /**
  * One way an item is sold: a name, a price and, for services, a duration.
  */
 export interface CatalogVariant {
     id: string;
+    catalog_item_id: string;
+    status: CatalogVariantStatus;
     name: string;
+    /** The business's own stock-keeping code. */
+    sku: string | null;
     /** In the currency's smallest unit (cents). `null` when no price is set; `0` is free. */
     price_amount: number | null;
     /** Three upper-case letters, e.g. `"USD"`. `null` exactly when `price_amount` is. */
@@ -12,52 +20,144 @@ export interface CatalogVariant {
     /** The variant to preselect. */
     is_default: boolean;
     sort_order: number;
+    version: number;
+    created_at: string;
+    updated_at: string;
 }
 /**
  * Something the business offers, with the variants it is sold in.
  */
 export interface CatalogItem {
     id: string;
+    kind: CatalogItemKind;
+    /** `active` is shown; `draft` and `archived` are not. */
+    status: CatalogItemStatus;
+    /** The site that sells it; `null` when every site of the business does. */
+    app_id: string | null;
     name: string;
     description: string | null;
     category: string | null;
     image_url: string | null;
     direct_purchase_enabled: boolean;
     /**
-     * Whether it can be ordered right now with `doany.orders.create`. An item
-     * that is shown but not purchasable is for display only.
+     * Whether it can be ordered right now with `doany.orders.create`: published,
+     * direct purchase on, and at least one active variant with a price.
      */
     purchasable: boolean;
     sort_order: number;
     /** In display order. */
     variants: CatalogVariant[];
+    version: number;
+    created_at: string;
+    updated_at: string;
 }
-export interface CatalogListParams {
-    category?: string;
+export interface CatalogListParams extends PageParams {
+    /** `active` (default), `draft`, `archived` or `all`. A visitor only ever sees `active`. */
+    status?: CatalogItemStatus | "all";
+    /**
+     * The items a site sells: its own and those every site sells. Defaults to
+     * this client's app; `null` lists every item of the business.
+     */
+    app_id?: string | null;
     /** Only items that can be ordered right now. */
     purchasable?: boolean;
-    limit?: number;
-    skip?: number;
-    /** A field name, `-` in front for descending: `sort_order` (default), `name`, `category`, `created_at`. */
-    sort?: string;
+    /** Which variants come with each item: `active` (default) or `all`. */
+    variant_status?: "active" | "all";
+    /** Part of the name. */
+    q?: string;
+    category?: string;
+    kind?: CatalogItemKind;
+}
+export interface CatalogVariantInput {
+    name: string;
+    sku?: string | null;
+    price_amount?: number | null;
+    currency?: string | null;
+    duration_minutes?: number | null;
+    /** At most one per item; with none, the first variant is the default. */
+    is_default?: boolean;
+    sort_order?: number;
+}
+export interface CreateCatalogItemParams {
+    name: string;
+    /** `service` (default), `physical` or `digital`. Cannot change later. */
+    kind?: CatalogItemKind;
+    description?: string | null;
+    category?: string | null;
+    /** An `http(s)://` URL. */
+    image_url?: string | null;
+    sort_order?: number;
+    /** The one site that sells it; left out or `null`, every site does. */
+    app_id?: string | null;
+    variants?: CatalogVariantInput[];
+}
+export interface UpdateCatalogItemParams extends VersionInput {
+    name?: string;
+    description?: string | null;
+    category?: string | null;
+    image_url?: string | null;
+    sort_order?: number;
+    app_id?: string | null;
+}
+export interface UpdateCatalogVariantParams extends VersionInput {
+    name?: string;
+    sku?: string | null;
+    price_amount?: number | null;
+    currency?: string | null;
+    duration_minutes?: number | null;
+    /** `true` also unsets the item's previous default. */
+    is_default?: boolean;
+    sort_order?: number;
 }
 /**
- * What the business offers. Read-only: the catalog is managed by the business
- * owner in Doany, not from the site.
+ * What the business offers: items and the variants they are sold in.
+ *
+ * Everyone can read what is published. Changing the catalog takes the site's
+ * admin account or a service credential (`asServiceRole`); others are refused
+ * with 403 (401 when nobody is signed in).
+ *
+ * Every change sends back the `version` it is based on; a stale one is
+ * refused with 409 `VERSION_CONFLICT` and `details.version` is the current one.
+ * A change that would leave a published, directly purchasable item without a
+ * priced variant, or mix currencies, is refused with 409 `NOT_PURCHASABLE`
+ * (`details.reason`).
  */
 export interface CatalogModule {
     /**
-     * The published items.
+     * The items this site sells.
      *
      * @example
      * ```typescript
-     * const items = await doany.catalog.list({ purchasable: true });
+     * const { data: items } = await doany.catalog.list({ purchasable: true });
      * ```
      */
-    list(params?: CatalogListParams): Promise<CatalogItem[]>;
-    /**
-     * One published item. Rejects with status 404 when there is no such item or
-     * it is not published.
-     */
-    get(itemId: string): Promise<CatalogItem>;
+    list(params?: CatalogListParams): Promise<Page<CatalogItem>>;
+    /** One item. Rejects with 404 when there is none, or the caller may not see it. */
+    get(itemId: string, params?: {
+        variant_status?: "active" | "all";
+    }): Promise<CatalogItem>;
+    /** A new item, as a `draft` with direct purchase off. */
+    create(params: CreateCatalogItemParams, options?: CreateOptions): Promise<CatalogItem>;
+    /** Changes the item's details. `status` and direct purchase have their own calls. */
+    update(itemId: string, params: UpdateCatalogItemParams): Promise<CatalogItem>;
+    /** `draft` → `active` (shown). */
+    publish(itemId: string, params: VersionInput): Promise<CatalogItem>;
+    /** → `archived`: no longer shown or sold; existing orders are unaffected. */
+    archive(itemId: string, params: VersionInput): Promise<CatalogItem>;
+    /** `archived` → `draft`, to be checked and published again. */
+    restore(itemId: string, params: VersionInput): Promise<CatalogItem>;
+    /** Turns ordering the item directly on the site on or off. */
+    setDirectPurchase(itemId: string, params: VersionInput & {
+        enabled: boolean;
+    }): Promise<CatalogItem>;
+    /** Deletes an item nothing refers to; otherwise 409 `IN_USE` (archive it instead). */
+    delete(itemId: string): Promise<void>;
+    /** A new variant of an item. */
+    createVariant(itemId: string, params: CatalogVariantInput, options?: CreateOptions): Promise<CatalogVariant>;
+    /** Changes a variant. A new price applies to orders placed from now on. */
+    updateVariant(variantId: string, params: UpdateCatalogVariantParams): Promise<CatalogVariant>;
+    archiveVariant(variantId: string, params: VersionInput): Promise<CatalogVariant>;
+    restoreVariant(variantId: string, params: VersionInput): Promise<CatalogVariant>;
+    /** Deletes a variant nothing refers to; otherwise 409 `IN_USE`. */
+    deleteVariant(variantId: string): Promise<void>;
 }

package/dist/modules/contacts.d.ts

@@ -0,0 +1,9 @@
+import { AxiosInstance } from "axios";
+import { ContactsModule } from "./contacts.types";
+import { ProjectScope } from "./project.js";
+/**
+ * Creates the contacts module: `/projects/{project_id}/contacts/...`.
+ *
+ * @internal
+ */
+export declare function createContactsModule(axios: AxiosInstance, project: ProjectScope): ContactsModule;

package/dist/modules/contacts.js

@@ -0,0 +1,42 @@
+import { idempotencyHeaders, queryOf, seg } from "./project.js";
+/**
+ * Creates the contacts module: `/projects/{project_id}/contacts/...`.
+ *
+ * @internal
+ */
+export function createContactsModule(axios, project) {
+    const contacts = (suffix = "") => project.path(`/contacts${suffix}`);
+    const post = async (suffix, data, headers) => (await axios.request({ method: "POST", url: await contacts(suffix), data, headers }));
+    return {
+        async list(params = {}) {
+            return (await axios.get(await contacts(), { params: queryOf(params) }));
+        },
+        async get(contactId) {
+            return (await axios.get(await contacts(`/${seg(contactId)}`)));
+        },
+        async me() {
+            return (await axios.get(await contacts("/me")));
+        },
+        create(params, options) {
+            return post("", params, idempotencyHeaders(options === null || options === void 0 ? void 0 : options.idempotencyKey));
+        },
+        async update(contactId, params) {
+            return (await axios.patch(await contacts(`/${seg(contactId)}`), params));
+        },
+        async updateMe(params) {
+            return (await axios.patch(await contacts("/me"), params));
+        },
+        archive(contactId, { version }) {
+            return post(`/${seg(contactId)}/archive`, { version });
+        },
+        restore(contactId, { version }) {
+            return post(`/${seg(contactId)}/restore`, { version });
+        },
+        merge(contactId, { into_contact_id, version }) {
+            return post(`/${seg(contactId)}/merge`, { into_contact_id, version });
+        },
+        async delete(contactId) {
+            await axios.delete(await contacts(`/${seg(contactId)}`));
+        },
+    };
+}