@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/tax/display-policy.d.ts

@@ -0,0 +1,105 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/** `channel` follows the store's "prices include tax"; `gross` = incl. tax; `net` = excl. tax. */
+export type TaxDisplayDefault = 'channel' | 'gross' | 'net';
+/** `inherit` leaves B2B and trade customers on the default. */
+export type TaxDisplayB2b = 'inherit' | 'gross' | 'net';
+/** What a shopper is shown: `GROSS` = incl. tax, `NET` = excl. tax (the Shop API's casing). */
+export type TaxDisplayMode = 'GROSS' | 'NET';
+/** The shoppers a policy is answered for, in the order a settings screen lists them. */
+export type TaxDisplayAudience = 'VISITOR' | 'RETAIL_CUSTOMER' | 'B2B_CUSTOMER' | 'LISTED_COUNTRY_CUSTOMER';
+/**
+ * A store's price-display policy: who sees prices with or without tax. Three Channel custom fields
+ * (`taxDisplayDefault`, `taxDisplayB2b`, `taxExclusiveCountries`), in the organization settings
+ * group `settings.tax_display`.
+ */
+export interface TaxDisplayPolicy {
+    default: TaxDisplayDefault;
+    b2b: TaxDisplayB2b;
+    /**
+     * Upper-case ISO-3166 alpha-2 codes; empty turns the rule off. A customer shipping to a listed
+     * country always sees prices excl. tax, whatever the other two say, AND is taxed by that
+     * country's tax zone instead of the store's: this list changes what customers are charged, not
+     * only what they are shown.
+     */
+    countries: string[];
+}
+export interface TaxDisplayAudienceAnswer {
+    audience: TaxDisplayAudience;
+    /** The listed country the answer is judged for (`LISTED_COUNTRY_CUSTOMER` only); else null. */
+    countryCode: string | null;
+    /** What this shopper is shown, by the rule the storefront applies. Null when `dependsOnStore`. */
+    mode: TaxDisplayMode | null;
+    /**
+     * True only in an organization's workspace, for an answer that falls back to "prices include
+     * tax": each member store keeps its own, so there is no one answer.
+     */
+    dependsOnStore: boolean;
+}
+/** A policy and who it shows which tax figure, as the engine answers it. */
+export interface TaxDisplayPolicyView extends TaxDisplayPolicy {
+    /** The store's own storage mode, the policy's last fallback. */
+    pricesIncludeTax: boolean;
+    /**
+     * Visitor, retail customer, B2B or trade customer, then a customer in the FIRST listed country
+     * (absent while none is listed). The same rule decides the storefront's prices and the prices an
+     * order's emails, receipts and invoices show its customer.
+     */
+    audiences: TaxDisplayAudienceAnswer[];
+}
+/**
+ * The ACTIVE store's price-display policy (`admin.tax.displayPolicy`). Reading needs any
+ * administrator permission on the store; writing needs `UpdateChannel` (the policy is stored on
+ * the channel and written through core `updateChannel`).
+ *
+ * The engine owns the rule: who sees what is never worked out in the client. Ask {@link preview}
+ * for a policy the merchant has not saved.
+ */
+export interface TaxDisplayPolicyModule {
+    /**
+     * The policy the storefront applies and who it shows which figure. For a store that inherits
+     * `settings.tax_display` from its organization this is the organization's policy. An unreadable
+     * stored value reads as its default (`channel` / `inherit` / no countries); a stored choice is
+     * read trimmed and lower-cased, as the storefront reads it.
+     *
+     * @effect read
+     */
+    get(options?: Call): Promise<TaxDisplayPolicyView>;
+    /**
+     * Who `policy` WOULD show which figure on this store, without saving anything.
+     *
+     * Refused `CHANNEL_SETTINGS_INVALID` (`ValidationError`, one `details[]` entry per field named
+     * `customFields.<field>`) for a policy the save would refuse: a choice that is not exactly one of
+     * the values above, a country code that is not two letters, a country listed twice, or more than
+     * 300 countries.
+     *
+     * @effect read
+     */
+    preview(policy: TaxDisplayPolicy, options?: Call): Promise<TaxDisplayPolicyView>;
+    /**
+     * Replace the whole policy, and answer it as the engine now applies it.
+     *
+     * Pass all three fields: read with {@link get}, change what you mean to, send it back. An empty
+     * country list clears the stored list.
+     *
+     * Refused, before anything is written, `CHANNEL_SETTINGS_INVALID` (`ValidationError`) for a policy
+     * {@link preview} refuses. Refused by the save itself:
+     * - `ORGANIZATION_SETTINGS_INHERITED` (`BusinessRuleError`, 422) while the store uses its
+     *   organization's policy: override it first (`tenant.settingsSources`), or change it in the
+     *   organization's workspace;
+     * - `MANAGED_BY_ORGANIZATION` (`BusinessRuleError`, 422) if the organization manages the group;
+     * - `FORBIDDEN` without `UpdateChannel`.
+     *
+     * @effect write
+     */
+    set(policy: TaxDisplayPolicy, options?: Call): Promise<TaxDisplayPolicyView>;
+}
+export declare const TAX_DISPLAY_POLICY_QUERY = "\n  query TaxDisplayPolicy {\n    taxDisplayPolicy { \n  default\n  b2b\n  countries\n  pricesIncludeTax\n  audiences {\n    audience\n    countryCode\n    mode\n    dependsOnStore\n  }\n }\n  }\n";
+export declare const PREVIEW_TAX_DISPLAY_POLICY_QUERY = "\n  query PreviewTaxDisplayPolicy($input: TaxDisplayPolicyInput!) {\n    previewTaxDisplayPolicy(input: $input) { \n  default\n  b2b\n  countries\n  pricesIncludeTax\n  audiences {\n    audience\n    countryCode\n    mode\n    dependsOnStore\n  }\n }\n  }\n";
+/**
+ * The save's first step: the engine judges the policy (the preview's refusal is the save's) and
+ * names the channel `updateChannel` must be given, in one request with the save's call options.
+ */
+export declare const CHECK_TAX_DISPLAY_POLICY_QUERY = "\n  query CheckTaxDisplayPolicy($input: TaxDisplayPolicyInput!) {\n    activeChannel { id }\n    previewTaxDisplayPolicy(input: $input) { default }\n  }\n";
+export declare const SET_TAX_DISPLAY_POLICY_MUTATION = "\n  mutation SetTaxDisplayPolicy($input: UpdateChannelInput!) {\n    updateChannel(input: $input) {\n      ... on Channel { id }\n      ... on ErrorResult { errorCode message }\n    }\n  }\n";
+export declare function createTaxDisplayPolicyModule(transport: Transport): TaxDisplayPolicyModule;

package/dist/tax/display-policy.js

@@ -0,0 +1,84 @@
+import { errorFromErrorResult, isErrorResult, } from '@sixtyninecommerce/core';
+const VIEW_FIELDS = /* GraphQL */ `
+  default
+  b2b
+  countries
+  pricesIncludeTax
+  audiences {
+    audience
+    countryCode
+    mode
+    dependsOnStore
+  }
+`;
+export const TAX_DISPLAY_POLICY_QUERY = /* GraphQL */ `
+  query TaxDisplayPolicy {
+    taxDisplayPolicy { ${VIEW_FIELDS} }
+  }
+`;
+export const PREVIEW_TAX_DISPLAY_POLICY_QUERY = /* GraphQL */ `
+  query PreviewTaxDisplayPolicy($input: TaxDisplayPolicyInput!) {
+    previewTaxDisplayPolicy(input: $input) { ${VIEW_FIELDS} }
+  }
+`;
+/**
+ * The save's first step: the engine judges the policy (the preview's refusal is the save's) and
+ * names the channel `updateChannel` must be given, in one request with the save's call options.
+ */
+export const CHECK_TAX_DISPLAY_POLICY_QUERY = /* GraphQL */ `
+  query CheckTaxDisplayPolicy($input: TaxDisplayPolicyInput!) {
+    activeChannel { id }
+    previewTaxDisplayPolicy(input: $input) { default }
+  }
+`;
+export const SET_TAX_DISPLAY_POLICY_MUTATION = /* GraphQL */ `
+  mutation SetTaxDisplayPolicy($input: UpdateChannelInput!) {
+    updateChannel(input: $input) {
+      ... on Channel { id }
+      ... on ErrorResult { errorCode message }
+    }
+  }
+`;
+/** Exactly the input the engine takes: no extra keys travel. */
+function inputOf(policy) {
+    return { default: policy.default, b2b: policy.b2b, countries: [...policy.countries] };
+}
+export function createTaxDisplayPolicyModule(transport) {
+    const get = async (options) => {
+        const data = await transport.graphql({ api: 'admin', query: TAX_DISPLAY_POLICY_QUERY }, options);
+        return data.taxDisplayPolicy;
+    };
+    return {
+        get,
+        async preview(policy, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: PREVIEW_TAX_DISPLAY_POLICY_QUERY,
+                variables: { input: inputOf(policy) },
+            }, options);
+            return data.previewTaxDisplayPolicy;
+        },
+        async set(policy, options) {
+            const input = inputOf(policy);
+            const checked = await transport.graphql({ api: 'admin', query: CHECK_TAX_DISPLAY_POLICY_QUERY, variables: { input } }, options);
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_TAX_DISPLAY_POLICY_MUTATION,
+                variables: {
+                    input: {
+                        id: checked.activeChannel.id,
+                        customFields: {
+                            taxDisplayDefault: input.default,
+                            taxDisplayB2b: input.b2b,
+                            // `null` is the column's "off", and the only value that clears a stored list.
+                            taxExclusiveCountries: input.countries.length === 0 ? null : JSON.stringify(input.countries),
+                        },
+                    },
+                },
+            }, options);
+            if (isErrorResult(data.updateChannel))
+                throw errorFromErrorResult(data.updateChannel);
+            return get(options);
+        },
+    };
+}

package/dist/tax/index.d.ts

@@ -1,5 +1,6 @@
 import { type Page, type Transport } from '@sixtyninecommerce/core';
-import type { Call } from '../types.js';
+import type { Call, ListOptions } from '../types.js';
+import { type TaxDisplayPolicyModule } from './display-policy.js';
 /**
  * The mapping used when no mapping names the country the money is taxed in.
  *
@@ -115,10 +116,87 @@ export interface TaxMappingsModule {
     /** Drop one country's mapping. Silent when there was none. */
     remove(key: string, countryCode: string, options?: Call): Promise<TaxClass>;
 }
+/**
+ * A platform-wide tax category (`Standard`, `Reduced`, `Zero`): what a tax class maps a country
+ * onto, and what a tax rate prices in a zone. Shared by every store.
+ */
+export interface TaxCategory {
+    id: string;
+    name: string;
+    /** The category the platform's own tax setup treats as the default. */
+    isDefault: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * A platform-wide tax rate: the percentage a category is taxed at in a zone, optionally only for
+ * one customer group.
+ */
+export interface TaxRate {
+    id: string;
+    name: string;
+    /** A percentage: `21` is 21 %. Not money. */
+    value: number;
+    /** A disabled rate is never applied. */
+    enabled: boolean;
+    category: {
+        id: string;
+        name: string;
+    };
+    zone: {
+        id: string;
+        name: string;
+    };
+    /** Null for a rate that applies to every customer. */
+    customerGroup: {
+        id: string;
+        name: string;
+    } | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** The platform's tax categories (read-only here; a SuperAdmin writes them through `platform.tax.categories`). */
+export interface TaxCategoriesModule {
+    /**
+     * Every tax category, in id order. Reading needs `ReadTaxCategory`, which every store role holds.
+     *
+     * A `Page`: walk it (`for await`, or `.next()` until null) for the COMPLETE list. Nothing is cut
+     * at a fixed size; every following page keeps the same order and per-call options.
+     *
+     * @effect read
+     */
+    list(options?: ListOptions): Promise<Page<TaxCategory>>;
+}
+/** The platform's tax rates (read-only here; a SuperAdmin writes them through `platform.tax.rates`). */
+export interface TaxRatesModule {
+    /**
+     * Every tax rate, in id order, with its category, zone and customer group. Reading needs
+     * `ReadTaxRate`, which every store role holds.
+     *
+     * A `Page`: walk it (`for await`, or `.next()` until null) for the COMPLETE list. Nothing is cut
+     * at a fixed size (the dashboard used to stop at 100); every following page keeps the same
+     * order and per-call options.
+     *
+     * @effect read
+     */
+    list(options?: ListOptions): Promise<Page<TaxRate>>;
+}
 export interface TaxModule {
     classes: TaxClassesModule;
     mappings: TaxMappingsModule;
+    /** The platform-wide tax categories every store shares. */
+    categories: TaxCategoriesModule;
+    /** The platform-wide tax rates every store shares. */
+    rates: TaxRatesModule;
+    /** Who the store shows prices with or without tax, saved or previewed. */
+    displayPolicy: TaxDisplayPolicyModule;
 }
+/** A {@link TaxCategory} as every read and write answers it (`platform.tax` reuses it). */
+export declare const TAX_CATEGORY_FIELDS = "\n  id\n  name\n  isDefault\n  createdAt\n  updatedAt\n";
+/** A {@link TaxRate} as every read and write answers it (`platform.tax` reuses it). */
+export declare const TAX_RATE_FIELDS = "\n  id\n  name\n  value\n  enabled\n  category { id name }\n  zone { id name }\n  customerGroup { id name }\n  createdAt\n  updatedAt\n";
+export declare const TAX_CATEGORIES_QUERY = "\n  query TaxCategories($options: TaxCategoryListOptions) {\n    taxCategories(options: $options) {\n      items { \n  id\n  name\n  isDefault\n  createdAt\n  updatedAt\n }\n      totalItems\n    }\n  }\n";
+export declare const TAX_RATES_QUERY = "\n  query TaxRates($options: TaxRateListOptions) {\n    taxRates(options: $options) {\n      items { \n  id\n  name\n  value\n  enabled\n  category { id name }\n  zone { id name }\n  customerGroup { id name }\n  createdAt\n  updatedAt\n }\n      totalItems\n    }\n  }\n";
 export declare const TAX_CLASSES_QUERY = "\n  query TaxClasses {\n    taxClasses { \n  id\n  key\n  label\n  mappings {\n    countryCode\n    taxCategoryId\n    taxCategory {\n      id\n      name\n      isDefault\n    }\n  }\n }\n  }\n";
 export declare const TAX_CLASS_QUERY = "\n  query TaxClass($key: String!) {\n    taxClass(key: $key) { \n  id\n  key\n  label\n  mappings {\n    countryCode\n    taxCategoryId\n    taxCategory {\n      id\n      name\n      isDefault\n    }\n  }\n }\n  }\n";
 export declare const UPSERT_TAX_CLASS_MUTATION = "\n  mutation UpsertTaxClass($input: UpsertTaxClassInput!) {\n    upsertTaxClass(input: $input) { \n  id\n  key\n  label\n  mappings {\n    countryCode\n    taxCategoryId\n    taxCategory {\n      id\n      name\n      isDefault\n    }\n  }\n }\n  }\n";

package/dist/tax/index.js

@@ -1,4 +1,6 @@
 import { createPage } from '@sixtyninecommerce/core';
+import { vendureListPage } from '../catalog/types.js';
+import { createTaxDisplayPolicyModule } from './display-policy.js';
 /**
  * The mapping used when no mapping names the country the money is taxed in.
  *
@@ -8,6 +10,49 @@ import { createPage } from '@sixtyninecommerce/core';
  * the same one read two ways.
  */
 export const TAX_CLASS_FALLBACK_COUNTRY = '*';
+/** A {@link TaxCategory} as every read and write answers it (`platform.tax` reuses it). */
+export const TAX_CATEGORY_FIELDS = /* GraphQL */ `
+  id
+  name
+  isDefault
+  createdAt
+  updatedAt
+`;
+/** A {@link TaxRate} as every read and write answers it (`platform.tax` reuses it). */
+export const TAX_RATE_FIELDS = /* GraphQL */ `
+  id
+  name
+  value
+  enabled
+  category { id name }
+  zone { id name }
+  customerGroup { id name }
+  createdAt
+  updatedAt
+`;
+export const TAX_CATEGORIES_QUERY = /* GraphQL */ `
+  query TaxCategories($options: TaxCategoryListOptions) {
+    taxCategories(options: $options) {
+      items { ${TAX_CATEGORY_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const TAX_RATES_QUERY = /* GraphQL */ `
+  query TaxRates($options: TaxRateListOptions) {
+    taxRates(options: $options) {
+      items { ${TAX_RATE_FIELDS} }
+      totalItems
+    }
+  }
+`;
+/**
+ * Vendure's list queries add no ORDER BY of their own, and `skip/take` over an unordered query
+ * can repeat or skip rows between two requests. Every list here is ordered by id, the one unique
+ * key a sort can name (a GraphQL sort input applies its fields in the SCHEMA's order, where `id`
+ * comes first, so `{ name, id }` is id order too), so a walk answers each row exactly once.
+ */
+const BY_ID = { id: 'ASC' };
 const TAX_CLASS_FIELDS = /* GraphQL */ `
   id
   key
@@ -56,6 +101,7 @@ export const REMOVE_TAX_CLASS_MAPPING_MUTATION = /* GraphQL */ `
 `;
 export function createTaxModule(transport) {
     return {
+        displayPolicy: createTaxDisplayPolicyModule(transport),
         classes: {
             async list(options) {
                 const data = await transport.graphql({ api: 'admin', query: TAX_CLASSES_QUERY }, options);
@@ -79,6 +125,12 @@ export function createTaxModule(transport) {
                 return data.deleteTaxClass;
             },
         },
+        categories: {
+            list: (options) => vendureListPage(transport, TAX_CATEGORIES_QUERY, 'taxCategories', (skip, take) => ({ options: { skip, take, sort: BY_ID } }), options),
+        },
+        rates: {
+            list: (options) => vendureListPage(transport, TAX_RATES_QUERY, 'taxRates', (skip, take) => ({ options: { skip, take, sort: BY_ID } }), options),
+        },
         mappings: {
             async set(key, countryCode, taxCategoryId, options) {
                 const data = await transport.graphql({

package/dist/tenant/email-style.d.ts

@@ -0,0 +1,102 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * The look of every email (and the PDF colours) the active store sends, as the engine applies it.
+ *
+ * The four choice fields name a member of a fixed set, which the engine checks on `set`:
+ * `fontFamily` `system` | `georgia` | `arial` | `verdana`; `logoPosition` `center` | `left`;
+ * `logoVariant` `light` | `dark` | `none` (which Business profile logo heads the email);
+ * `buttonStyle` `filled` | `outline`. They are typed `string` because a store can hold a value
+ * from before that check, which `get` answers as stored and `set` accepts back unchanged.
+ */
+export interface EmailStyle {
+    /** The active store. The style read is always the active store's, also while it inherits. */
+    channelId: string;
+    /**
+     * Buttons and links. Each colour is a hex (`#1a2b3c`, 3 to 8 digits), `rgb(r, g, b)`, a colour
+     * name or `transparent`.
+     */
+    accentColor: string;
+    /** The outer background; `transparent` lets a mail client's dark mode show through. */
+    backgroundColor: string;
+    /** The content area's background. */
+    contentBgColor: string;
+    textColor: string;
+    mutedTextColor: string;
+    fontFamily: string;
+    /** Pixels. */
+    headingFontSize: number;
+    /** Pixels. */
+    bodyFontSize: number;
+    logoPosition: string;
+    /** Pixels. */
+    logoMaxWidth: number;
+    logoVariant: string;
+    /** A button's corner radius, in pixels. */
+    borderRadius: number;
+    /** The content column's width, in pixels. */
+    contentWidth: number;
+    buttonStyle: string;
+}
+/**
+ * The style fields a `set` changes; an omitted field keeps its value. The sizes are whole pixels
+ * (GraphQL `Int`). `channelId` is not an input: `set` leaves it out, so `set({ ...style, … })`
+ * with a style `get` answered works.
+ */
+export type EmailStylePatch = Partial<Omit<EmailStyle, 'channelId'>>;
+/**
+ * `admin.tenant.emailStyle` — the active store's email style (part of the `settings.email` group).
+ * Always the ACTIVE channel; no channel argument.
+ *
+ * **A store that takes `settings.email` from its organization** (`admin.tenant.settingsSources`:
+ * locked, or inheritable and not overridden) sends its organization's style, and `get` answers
+ * that one. `set` then refuses any change; sending back what `get` answered is accepted and
+ * changes nothing. `admin.tenant.settingsSources.override('settings.email')` first to keep a style
+ * of the store's own.
+ */
+export interface EmailStyleModule {
+    /**
+     * The style the store's emails use: its own, its organization's while it inherits, or the
+     * platform's defaults while it has saved none. Needs `ReadSettings`.
+     *
+     * @effect read
+     * @permission ReadSettings
+     */
+    get(options?: Call): Promise<EmailStyle>;
+    /**
+     * Change the fields `patch` names, and answer the whole style as the engine now stores it. The
+     * next email the store sends uses it; emails already sent keep theirs.
+     *
+     * **Coded refusals:**
+     * - `EMAIL_STYLE_COLOR_INVALID` → `ValidationError` (400): a colour that is not a hex, `rgb(…)`,
+     *   colour name or `transparent`. The message names the field.
+     * - `EMAIL_STYLE_FONT_FAMILY_INVALID`, `EMAIL_STYLE_LOGO_POSITION_INVALID`,
+     *   `EMAIL_STYLE_BUTTON_STYLE_INVALID`, `EMAIL_LOGO_VARIANT_INVALID` → `ValidationError` (400):
+     *   a choice outside its set (see {@link EmailStyle}). Sending back the value the store holds
+     *   passes, even one from before the check.
+     * - `BAD_USER_INPUT` → `ValidationError` (400): a key that is not a style field, or a value of
+     *   the wrong type (a size that is not a whole number). The message names it.
+     * - `MANAGED_BY_ORGANIZATION` → `BusinessRuleError` (422): a changed field while the
+     *   organization locks `settings.email`.
+     * - `ORGANIZATION_SETTINGS_INHERITED` → `BusinessRuleError` (422): a changed field while the
+     *   store inherits `settings.email`; `tenant.settingsSources.override` it first.
+     * - `FORBIDDEN` → `PermissionDeniedError` (403): the credential lacks `UpdateSettings`.
+     *
+     * The sizes have no engine bounds yet; a UI should keep its own.
+     *
+     * @effect write
+     * @permission UpdateSettings
+     */
+    set(patch: EmailStylePatch, options?: Call): Promise<EmailStyle>;
+}
+/** The style fields, in the order the engine's input lists them. */
+export declare const EMAIL_STYLE_FIELDS = "\n  channelId\n  accentColor\n  backgroundColor\n  contentBgColor\n  textColor\n  mutedTextColor\n  fontFamily\n  headingFontSize\n  bodyFontSize\n  logoPosition\n  logoMaxWidth\n  logoVariant\n  borderRadius\n  contentWidth\n  buttonStyle\n";
+export declare const EMAIL_STYLE_QUERY = "\n  query EmailStyle {\n    emailStyleConfig { \n  channelId\n  accentColor\n  backgroundColor\n  contentBgColor\n  textColor\n  mutedTextColor\n  fontFamily\n  headingFontSize\n  bodyFontSize\n  logoPosition\n  logoMaxWidth\n  logoVariant\n  borderRadius\n  contentWidth\n  buttonStyle\n }\n  }\n";
+export declare const SET_EMAIL_STYLE_MUTATION = "\n  mutation SetEmailStyle($input: UpdateEmailStyleConfigInput!) {\n    updateEmailStyleConfig(input: $input) { \n  channelId\n  accentColor\n  backgroundColor\n  contentBgColor\n  textColor\n  mutedTextColor\n  fontFamily\n  headingFontSize\n  bodyFontSize\n  logoPosition\n  logoMaxWidth\n  logoVariant\n  borderRadius\n  contentWidth\n  buttonStyle\n }\n  }\n";
+/**
+ * The patch as the engine's `UpdateEmailStyleConfigInput` takes it. Every other key goes through
+ * as given, so the engine refuses a misspelt or unknown one (`BAD_USER_INPUT`) instead of the SDK
+ * dropping it and answering success; `channelId` alone is left out (see {@link EmailStylePatch}).
+ */
+export declare function emailStyleInputOf(patch: EmailStylePatch): Record<string, unknown>;
+export declare function createEmailStyleModule(transport: Transport): EmailStyleModule;

package/dist/tenant/email-style.js

@@ -0,0 +1,72 @@
+/** The style fields, in the order the engine's input lists them. */
+export const EMAIL_STYLE_FIELDS = /* GraphQL */ `
+  channelId
+  accentColor
+  backgroundColor
+  contentBgColor
+  textColor
+  mutedTextColor
+  fontFamily
+  headingFontSize
+  bodyFontSize
+  logoPosition
+  logoMaxWidth
+  logoVariant
+  borderRadius
+  contentWidth
+  buttonStyle
+`;
+export const EMAIL_STYLE_QUERY = /* GraphQL */ `
+  query EmailStyle {
+    emailStyleConfig { ${EMAIL_STYLE_FIELDS} }
+  }
+`;
+export const SET_EMAIL_STYLE_MUTATION = /* GraphQL */ `
+  mutation SetEmailStyle($input: UpdateEmailStyleConfigInput!) {
+    updateEmailStyleConfig(input: $input) { ${EMAIL_STYLE_FIELDS} }
+  }
+`;
+function fromWire(wire) {
+    return {
+        channelId: String(wire.channelId),
+        accentColor: wire.accentColor,
+        backgroundColor: wire.backgroundColor,
+        contentBgColor: wire.contentBgColor,
+        textColor: wire.textColor,
+        mutedTextColor: wire.mutedTextColor,
+        fontFamily: wire.fontFamily,
+        headingFontSize: wire.headingFontSize,
+        bodyFontSize: wire.bodyFontSize,
+        logoPosition: wire.logoPosition,
+        logoMaxWidth: wire.logoMaxWidth,
+        logoVariant: wire.logoVariant,
+        borderRadius: wire.borderRadius,
+        contentWidth: wire.contentWidth,
+        buttonStyle: wire.buttonStyle,
+    };
+}
+/**
+ * The patch as the engine's `UpdateEmailStyleConfigInput` takes it. Every other key goes through
+ * as given, so the engine refuses a misspelt or unknown one (`BAD_USER_INPUT`) instead of the SDK
+ * dropping it and answering success; `channelId` alone is left out (see {@link EmailStylePatch}).
+ */
+export function emailStyleInputOf(patch) {
+    const { channelId: _readOnly, ...input } = patch;
+    return input;
+}
+export function createEmailStyleModule(transport) {
+    return {
+        async get(options) {
+            const data = await transport.graphql({ api: 'admin', query: EMAIL_STYLE_QUERY }, options);
+            return fromWire(data.emailStyleConfig);
+        },
+        async set(patch, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_EMAIL_STYLE_MUTATION,
+                variables: { input: emailStyleInputOf(patch) },
+            }, options);
+            return fromWire(data.updateEmailStyleConfig);
+        },
+    };
+}