@swell/apps-sdk 1.0.13 → 1.0.14

package/dist/src/api.d.ts

@@ -0,0 +1,91 @@
+import SwellJS from 'swell-js';
+import { Cache } from './cache';
+export * from './resources';
+import type { SwellAppConfig, SwellErrorOptions, SwellMenu, SwellData, CFThemeEnv } from '../types/swell';
+export declare class Swell {
+    url: URL;
+    headers: SwellData;
+    swellHeaders: SwellData;
+    queryParams: SwellData;
+    workerEnv?: CFThemeEnv;
+    config?: SwellAppConfig;
+    backend?: SwellBackendAPI;
+    storefront: typeof SwellJS;
+    instanceId: string;
+    isPreview: boolean;
+    isEditor: boolean;
+    sentResponse: boolean;
+    static cache: Map<string, Cache>;
+    constructor(params: {
+        url: URL | string;
+        config?: SwellAppConfig;
+        headers?: SwellData;
+        swellHeaders?: SwellData;
+        serverHeaders?: Headers | SwellData;
+        queryParams?: URLSearchParams | SwellData;
+        workerEnv?: any;
+        getCookie?: (name: string) => string;
+        setCookie?: (name: string, value: string, options: any) => void;
+        [key: string]: any;
+    });
+    static formatHeaders(serverHeaders?: Headers | SwellData): {
+        headers: SwellData;
+        swellHeaders: SwellData;
+    };
+    static formatQueryParams(queryParams?: URLSearchParams | SwellData): SwellData;
+    getClientProps(): {
+        url: URL;
+        headers: SwellData;
+        swellHeaders: SwellData;
+        queryParams: SwellData;
+        instanceId: string;
+        isPreview: boolean;
+        isEditor: boolean;
+        cache: [string, any][];
+        storefrontSettingStates: {
+            state: any;
+            menuState: any;
+            paymentState: any;
+            subscriptionState: any;
+            sessionState: any;
+        };
+    };
+    getStorefrontInstance(params: SwellData): swell;
+    isStorefrontRequestCacheable(method: string, url: string): boolean;
+    getCacheableStorefrontRequestHandler(storefront: typeof SwellJS): (method: string, url: string, id?: any, data?: any, opt?: any) => Promise<any>;
+    getCacheInstance(): Cache;
+    setCacheValues(values: Array<any>): void;
+    setCachedSync(key: string, args: Array<any>, value: any, timeout?: number, isSync?: boolean): void | Promise<void>;
+    getCachedSync(key: string, args?: Array<any> | Function, handler?: Function, timeout?: number, isSync?: boolean): any;
+    resolveCacheHandler(cacheInstance: Cache, cacheKey: string, cacheHandler: Function, timeout?: number, isSync?: boolean): any;
+    setCached(key: string, args: Array<any>, value: any, timeout?: number): Promise<any>;
+    getCached(key: string, args: Array<any> | Function, handler?: Function, timeout?: number): Promise<any>;
+    getCachedResource(key: string, args: Array<any> | Function, handler?: Function, timeout?: number): Promise<any>;
+    clearCache(): void;
+    getAppSettings(): Promise<SwellData>;
+    getStorefrontSettings(): Promise<SwellData>;
+    getStorefrontMenus(): SwellMenu[];
+    get(...args: Parameters<SwellBackendAPI['get']>): Promise<SwellData> | undefined;
+    put(...args: Parameters<SwellBackendAPI['put']>): Promise<SwellData> | undefined;
+    post(...args: Parameters<SwellBackendAPI['post']>): Promise<SwellData> | undefined;
+    delete(...args: Parameters<SwellBackendAPI['delete']>): Promise<SwellData> | undefined;
+}
+export declare class SwellBackendAPI {
+    apiHost: string;
+    apiAuth: string;
+    constructor({ storeId, accessToken, apiHost, }: {
+        storeId: string;
+        accessToken: string;
+        apiHost?: string;
+    });
+    makeRequest(method: string, url: string, data?: object): Promise<any>;
+    stringifyQuery(queryObject: object, prefix?: string): string;
+    get(url: string, query?: SwellData): Promise<SwellData>;
+    put(url: string, data: SwellData): Promise<SwellData>;
+    post(url: string, data: SwellData): Promise<SwellData>;
+    delete(url: string, data?: SwellData): Promise<SwellData>;
+}
+export declare class SwellError extends Error {
+    status: number;
+    constructor(message: string, options?: SwellErrorOptions);
+}

package/dist/src/cache.d.ts

@@ -0,0 +1,17 @@
+import type { CFWorkerKV } from 'types/swell';
+export declare class Cache {
+    private map;
+    private kvStore?;
+    private timeoutDefault;
+    constructor(kvStore?: CFWorkerKV, timeoutDefault?: number);
+    setValues(values: Array<any>): void;
+    getValues(): [string, any][];
+    get(key: string): Promise<any>;
+    getSync(key: string): any;
+    set(key: string, value: any, timeout?: number): Promise<void>;
+    setSync(key: string, value: any, timeout?: number): void;
+    delete(key: string): Promise<void>;
+    deleteSync(key: string): void;
+    has(key: string): Promise<any>;
+    hasSync(key: string): boolean;
+}

package/dist/src/categories.d.ts

@@ -0,0 +1,5 @@
+import { Swell, SwellStorefrontCollection, SwellStorefrontRecord } from './api';
+import type { SwellData } from '../types/swell';
+export declare function getCategories(swell: Swell, query?: SwellData): SwellStorefrontCollection;
+export declare function getCategory(swell: Swell, id: string, query?: SwellData): SwellStorefrontRecord;
+export declare function getCategoryWithProducts(swell: Swell, id: string, query?: SwellData): Promise<SwellStorefrontRecord>;

package/dist/src/compatibility/shopify-configs.d.ts

@@ -0,0 +1,10 @@
+import type { ShopifySectionBlockSchema, ShopifySectionPresetSchema, ShopifySectionSchema, ShopifySettingSchema, ShopifySettingsData, ShopifySettingSection, ShopifySettingsSchema } from 'types/shopify';
+import type { ThemeBlockSchema, ThemeEditorSchema, ThemePresetSchema, ThemeSectionSchema, ThemeSettingFieldSchema, ThemeSettings, ThemeSettingSectionSchema } from 'types/swell';
+export declare function convertShopifySettingsSchema(settingsSchema: ShopifySettingsSchema): ThemeEditorSchema;
+export declare function convertShopifySettingsData(settingsData: ShopifySettingsData): ThemeSettings;
+export declare function convertShopifySettingsPresets(settingsData: ShopifySettingsData): ThemePresetSchema[];
+export declare function convertShopifySectionSchema(sectionSchema: ShopifySectionSchema): ThemeSectionSchema;
+export declare function shopifySchemaBlockToSwellBlockSchema(block: ShopifySectionBlockSchema): ThemeBlockSchema;
+export declare function shopifySchemaPresetToSwellPresetSchema(preset: ShopifySectionPresetSchema): ThemePresetSchema;
+export declare function shopifySchemaSectionToSwellSettingSection(section: ShopifySettingSection): ThemeSettingSectionSchema;
+export declare function shopifySchemaSettingToSwellSettingField(setting: ShopifySettingSchema): ThemeSettingFieldSchema;

package/dist/src/compatibility/shopify-fonts.d.ts

@@ -0,0 +1 @@
+export declare function shopifyFontToThemeFront(shopifyFontSetting: string): string | null;

package/dist/src/compatibility/shopify-objects/address.d.ts

@@ -0,0 +1,6 @@
+import { StorefrontResource } from '../../resources';
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellRecord } from 'types/swell';
+export default function ShopifyAddress(instance: ShopifyCompatibility, address: StorefrontResource | SwellRecord): ShopifyResource;
+export declare function ShopifyCountry(_instance: ShopifyCompatibility, countryCode: string): ShopifyResource;

package/dist/src/compatibility/shopify-objects/article.d.ts

@@ -0,0 +1,5 @@
+import { StorefrontResource } from '../../resources';
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellRecord } from 'types/swell';
+export default function ShopifyArticle(instance: ShopifyCompatibility, blog: StorefrontResource | SwellRecord, blogCategory?: StorefrontResource | SwellRecord): ShopifyResource;

package/dist/src/compatibility/shopify-objects/blog.d.ts

@@ -0,0 +1,5 @@
+import { StorefrontResource } from '../../resources';
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellRecord } from 'types/swell';
+export default function ShopifyBlog(instance: ShopifyCompatibility, blogCategory: StorefrontResource | SwellRecord): ShopifyResource;

package/dist/src/compatibility/shopify-objects/cart.d.ts

@@ -0,0 +1,5 @@
+import { StorefrontResource } from '../../resources';
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellRecord } from 'types/swell';
+export default function ShopifyCart(instance: ShopifyCompatibility, cart: StorefrontResource | SwellRecord): ShopifyResource;

package/dist/src/compatibility/shopify-objects/collection.d.ts

@@ -0,0 +1,5 @@
+import { StorefrontResource } from '../../resources';
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellRecord } from 'types/swell';
+export default function ShopifyCollection(instance: ShopifyCompatibility, category: StorefrontResource | SwellRecord): ShopifyResource;

package/dist/src/compatibility/shopify-objects/collections.d.ts

@@ -0,0 +1,3 @@
+import { ShopifyCompatibility } from '../shopify';
+import { SwellStorefrontCollection } from '../../resources';
+export default function ShopifyCollections(instance: ShopifyCompatibility, categories: SwellStorefrontCollection): SwellStorefrontCollection;

package/dist/src/compatibility/shopify-objects/customer.d.ts

@@ -0,0 +1,5 @@
+import { StorefrontResource } from '../../resources';
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellRecord } from 'types/swell';
+export default function ShopifyCustomer(instance: ShopifyCompatibility, account: StorefrontResource | SwellRecord): ShopifyResource;

package/dist/src/compatibility/shopify-objects/filter.d.ts

@@ -0,0 +1,5 @@
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellData, SwellRecord } from 'types/swell';
+export default function ShopifyFilter(instance: ShopifyCompatibility, filter: SwellRecord): ShopifyResource;
+export declare function ShopifyFilterValue(instance: ShopifyCompatibility, filterOption: SwellData, filter: SwellRecord, paramSuffix?: string): ShopifyResource;

package/dist/src/compatibility/shopify-objects/font.d.ts

@@ -0,0 +1,4 @@
+import { ShopifyCompatibility } from '../shopify';
+import { ThemeFont } from '../../liquid/font';
+import { ShopifyResource } from './resource';
+export default function ShopifyFont(_instance: ShopifyCompatibility, font: ThemeFont): ShopifyResource;

package/dist/src/compatibility/shopify-objects/form.d.ts

@@ -0,0 +1,28 @@
+import { ShopifyCompatibility } from '../shopify';
+import { ThemeForm } from '../../liquid/form';
+import { ShopifyResource } from './resource';
+export default function ShopifyForm(_instance: ShopifyCompatibility, form: ThemeForm): ShopifyResource;
+export declare class ShopifyFormError {
+    code: string;
+    message: string;
+    field_name: string;
+    field_label: string;
+    type: string;
+    constructor(error: any);
+    getShopifyErrorType(error: any): "email" | "password" | "form";
+    valueOf(): string;
+    toString(): string;
+}
+export declare class ShopifyFormErrors {
+    private errors;
+    private pointer;
+    messages: ShopifyFormErrorArrayByType;
+    translated_fields: ShopifyFormErrorArrayByType;
+    constructor(errors: any);
+    [Symbol.iterator](): Generator<any, void, undefined>;
+    some(callbackFn: any, thisArg?: any): boolean;
+}
+export declare class ShopifyFormErrorArrayByType {
+    values: any[];
+    constructor(errors: any, values: any);
+}

package/dist/src/compatibility/shopify-objects/image.d.ts

@@ -0,0 +1,6 @@
+import { StorefrontResource } from '../../resources';
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellData, SwellRecord } from 'types/swell';
+export default function ShopifyImage(_instance: ShopifyCompatibility, image: SwellData, product?: StorefrontResource | SwellRecord, variant?: StorefrontResource | SwellRecord): ShopifyResource;
+export declare function ShopifyImageSrc(file: SwellData): ShopifyResource;

package/dist/src/compatibility/shopify-objects/index.d.ts

@@ -0,0 +1,26 @@
+import { ShopifyCompatibility } from '../shopify';
+import { DeferredShopifyResource, ShopifyResource } from './resource';
+import ShopifyArticle from './article';
+import ShopifyBlog from './blog';
+import ShopifyCart from './cart';
+import ShopifyCollection from './collection';
+import ShopifyCollections from './collections';
+import ShopifyCustomer from './customer';
+import ShopifyFont from './font';
+import ShopifyForm from './form';
+import ShopifyOrder from './order';
+import ShopifyPaginate from './paginate';
+import ShopifyPredictiveSearch from './predictive_search';
+import ShopifyProduct from './product';
+import ShopifyPage from './page';
+import ShopifyLink from './link';
+import ShopifyLocalization from './localization';
+import ShopifySearch from './search';
+import ShopifyVariant from './variant';
+import type { ThemeFont } from '../../liquid/font';
+import type { ThemeForm } from '../../liquid/form';
+import type { SwellMenu, SwellData } from '../../../types/swell';
+export { DeferredShopifyResource, ShopifyResource, ShopifyArticle, ShopifyBlog, ShopifyCart, ShopifyCollection, ShopifyCollections, ShopifyCustomer, ShopifyFont, ShopifyForm, ShopifyOrder, ShopifyPaginate, ShopifyPredictiveSearch, ShopifyProduct, ShopifyPage, ShopifyLink, ShopifyLocalization, ShopifySearch, ShopifyVariant, };
+export declare function adaptShopifyMenuData(instance: ShopifyCompatibility, menu: SwellMenu): SwellData;
+export declare function adaptShopifyFontData(instance: ShopifyCompatibility, font: ThemeFont): SwellData;
+export declare function adaptShopifyFormData(instance: ShopifyCompatibility, form: ThemeForm): SwellData;

package/dist/src/compatibility/shopify-objects/line_item.d.ts

@@ -0,0 +1,6 @@
+import { StorefrontResource } from '../../resources';
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellData, SwellRecord } from 'types/swell';
+export default function ShopifyLineItem(instance: ShopifyCompatibility, item: StorefrontResource | SwellRecord, cart: StorefrontResource | SwellRecord, options?: SwellData): ShopifyResource;
+export declare function countItemQuantity(items: any[], quantityField?: string): any;

package/dist/src/compatibility/shopify-objects/link.d.ts

@@ -0,0 +1,4 @@
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellMenu, SwellMenuItem } from 'types/swell';
+export default function ShopifyLink(instance: ShopifyCompatibility, parent: SwellMenu | SwellMenuItem, menuItem: SwellMenuItem): ShopifyResource;

package/dist/src/compatibility/shopify-objects/localization.d.ts

@@ -0,0 +1,4 @@
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellData } from 'types/swell';
+export default function ShopifyLocalization(_instance: ShopifyCompatibility, store: SwellData, request: SwellData): ShopifyResource;

package/dist/src/compatibility/shopify-objects/media.d.ts

@@ -0,0 +1,4 @@
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellData } from 'types/swell';
+export default function ShopifyMedia(_instance: ShopifyCompatibility, image: SwellData): ShopifyResource;

package/dist/src/compatibility/shopify-objects/order.d.ts

@@ -0,0 +1,10 @@
+import { StorefrontResource } from '../../resources';
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellRecord } from 'types/swell';
+export default function ShopifyOrder(instance: ShopifyCompatibility, order: StorefrontResource | SwellRecord, account?: StorefrontResource | SwellRecord): ShopifyResource;
+export declare function shopifyFinancialStatus(order: any): "refund_due" | "partially_paid" | "partially_refunded" | "refunded" | "paid" | "authorized" | "unpaid" | "complete";
+export declare function shopifyFulfillmentStatus(order: any): "complete" | "canceled" | "on_hold" | "returned" | "rartially_returned" | "fulfilled" | "partially_fulfilled" | "unfulfilled";
+export declare function shopifyFinancialStatusLabel(order: any): string;
+export declare function shopifyFulfillmentStatusLabel(order: any): string;
+export declare function refundDue(order: any): any;

package/dist/src/compatibility/shopify-objects/page.d.ts

@@ -0,0 +1,4 @@
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellData } from 'types/swell';
+export default function ShopifyPage(_instance: ShopifyCompatibility, page: SwellData): ShopifyResource;

package/dist/src/compatibility/shopify-objects/paginate.d.ts

@@ -0,0 +1,4 @@
+import { ShopifyCompatibility } from '../shopify';
+import { SwellStorefrontPagination } from '../../resources';
+import { ShopifyResource } from './resource';
+export default function ShopifyPaginate(instance: ShopifyCompatibility, pagination: SwellStorefrontPagination): ShopifyResource;

package/dist/src/compatibility/shopify-objects/predictive_search.d.ts

@@ -0,0 +1,4 @@
+import { ShopifyCompatibility } from '../shopify';
+import { StorefrontResource } from '../../resources';
+import { ShopifyResource } from './resource';
+export default function ShopifyPredictiveSearch(instance: ShopifyCompatibility, search: StorefrontResource): ShopifyResource;

package/dist/src/compatibility/shopify-objects/product.d.ts

@@ -0,0 +1,6 @@
+import { StorefrontResource } from '../../resources';
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellData, SwellRecord } from 'types/swell';
+export default function ShopifyProduct(instance: ShopifyCompatibility, product: StorefrontResource | SwellRecord, depth?: number): ShopifyResource | null;
+export declare function ShopifyProductOption(values: SwellData): ShopifyResource;

package/dist/src/compatibility/shopify-objects/resource.d.ts

@@ -0,0 +1,23 @@
+import { ShopifyCompatibility } from '../shopify';
+export declare class ShopifyResource {
+    props: {
+        [key: string]: any;
+    };
+    stringProp?: string;
+    linkProps?: string[];
+    constructor(props: any, stringProp?: string, linkProps?: string[]);
+    valueOf(): any;
+    clone(): ShopifyResource;
+}
+export declare class DeferredShopifyResource<T> {
+    private handler;
+    private result;
+    constructor(handler: () => Promise<T> | T);
+    resolve(): Promise<T | (T & {}) | null>;
+}
+export declare function defer<T>(handler: () => Promise<T> | T): DeferredShopifyResource<T>;
+export declare function isResolvable(asyncProp: unknown): boolean;
+export declare function resolveAsyncProp<R>(asyncProp: unknown): Promise<R>;
+export declare function handleDeferredProp<T, R>(asyncProp: unknown, handler: (...value: R[]) => T): Promise<T | null>;
+export declare function deferWith<T, R>(asyncProp: unknown, handler: (...value: R[]) => T): DeferredShopifyResource<T | null>;
+export declare function deferSwellCollectionWithShopifyResults(instance: ShopifyCompatibility, asyncProp: any, key: string, ShopifyObject: any, handler?: Function): DeferredShopifyResource<any>;

package/dist/src/compatibility/shopify-objects/search.d.ts

@@ -0,0 +1,4 @@
+import { ShopifyCompatibility } from '../shopify';
+import { StorefrontResource } from '../../resources';
+import { ShopifyResource } from './resource';
+export default function ShopifySearch(instance: ShopifyCompatibility, search: StorefrontResource): ShopifyResource;

package/dist/src/compatibility/shopify-objects/shop.d.ts

@@ -0,0 +1,4 @@
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellData } from 'types/swell';
+export default function ShopifyShop(_instance: ShopifyCompatibility, store: SwellData): ShopifyResource;

package/dist/src/compatibility/shopify-objects/variant.d.ts

@@ -0,0 +1,5 @@
+import { StorefrontResource } from '../../resources';
+import { ShopifyCompatibility } from '../shopify';
+import { ShopifyResource } from './resource';
+import type { SwellRecord } from 'types/swell';
+export default function ShopifyVariant(instance: ShopifyCompatibility, variant: StorefrontResource | SwellRecord, productIn?: StorefrontResource | SwellRecord, depth?: number): ShopifyResource;

package/dist/src/compatibility/shopify.d.ts

@@ -0,0 +1,71 @@
+import { Swell } from '../api';
+import { SwellTheme } from '../theme';
+import { ThemeFont } from '../liquid/font';
+import { ThemeForm } from '../liquid/form';
+import type { ThemeGlobals, ThemeSettings, ThemePresetSchema, ThemeEditorSchema, ThemeSectionSchema, SwellData, SwellMenu, SwellRecord } from '../../types/swell';
+import type { ShopifySettingsData, ShopifySettingsSchema, ShopifySectionSchema, ShopifyPageResourceMap, ShopifyObjectResourceMap, ShopifyFormResourceMap, ShopifyQueryParamsMap } from '../../types/shopify';
+export declare class ShopifyCompatibility {
+    theme: SwellTheme;
+    swell: Swell;
+    pageId?: string;
+    pageResourceMap: ShopifyPageResourceMap;
+    objectResourceMap: ShopifyObjectResourceMap;
+    formResourceMap: ShopifyFormResourceMap;
+    queryParamsMap: ShopifyQueryParamsMap;
+    editorLocaleConfig: {
+        [key: string]: any;
+    } | undefined;
+    constructor(theme: SwellTheme);
+    adaptGlobals(globals: ThemeGlobals): void;
+    adaptPageData(pageData: SwellData): void;
+    adaptObjectData(objectData: SwellData): void;
+    adaptQueryParams(): void;
+    getAdaptedFormType(shopifyType: string): string | undefined;
+    getAdaptedFormClientParams(formType: string, scope: SwellData, arg?: any): Promise<SwellData | undefined>;
+    getAdaptedFormClientHtml(formType: string, scope: SwellData, arg?: any): Promise<string | undefined>;
+    getAdaptedFormServerParams(formType: string, context: SwellData): Promise<SwellData | undefined>;
+    getAdaptedFormServerResponse(formType: string, context: SwellData): Promise<SwellData | undefined>;
+    getShopData({ store }: ThemeGlobals): {};
+    getContentForHeader(): string;
+    getMenuData(menu: SwellMenu): SwellData;
+    getFontData(font: ThemeFont): SwellData;
+    getFormData(form: ThemeForm): SwellData;
+    getFontFromShopifySetting(fontSetting: string): string | null;
+    getThemeConfig(settingsData: ShopifySettingsData): ThemeSettings;
+    getPresetsConfig(settingsData: ShopifySettingsData): ThemePresetSchema[];
+    getEditorConfig(settingsSchema: ShopifySettingsSchema): ThemeEditorSchema;
+    getSectionConfigSchema(sectionSchema: ShopifySectionSchema): ThemeSectionSchema;
+    getLocaleConfig(theme: SwellTheme, localeCode?: string, suffix?: string): Promise<any>;
+    getEditorLocaleConfig(theme: SwellTheme, localeCode: string): Promise<any>;
+    renderSchemaTranslations(theme: SwellTheme, schema: SwellData, localeCode?: string): Promise<any>;
+    renderSchemaTranslationValue(theme: SwellTheme, schemaValue: any, localCode: string, editorLocaleConfig: any): Promise<any>;
+    getPageType(pageId: string): string;
+    getPageRouteUrl(pageId: string): string;
+    getPageRoutes(): {
+        account_addresses_url: string;
+        account_login_url: string;
+        account_logout_url: string;
+        account_recover_url: string;
+        account_register_url: string;
+        account_url: string;
+        all_products_collection_url: string;
+        cart_add_url: string;
+        cart_change_url: string;
+        cart_clear_url: string;
+        cart_update_url: string;
+        cart_url: string;
+        collections_url: string;
+        predictive_search_url: string;
+        product_recommendations_url: string;
+        root_url: string;
+        search_url: string;
+    };
+    getLocalizationObject(store: SwellData, request: SwellData): import("./shopify-objects").ShopifyResource;
+    getAdaptedPageUrl(url: string): string | undefined;
+    getThemeFilePath(type: string, name: string): string;
+    getPageResourceMap(): ShopifyPageResourceMap;
+    getObjectResourceMap(): ShopifyObjectResourceMap;
+    getFormResourceMap(): ShopifyFormResourceMap;
+    getQueryParamsMap(): ShopifyQueryParamsMap;
+    getAllCountryOptionTags(geoSettings: SwellRecord): any;
+}

package/dist/src/constants.d.ts

@@ -0,0 +1 @@
+export declare const LANG_TO_COUNTRY_CODES: Record<string, string | undefined>;

package/dist/src/content.d.ts

@@ -0,0 +1,8 @@
+import { Swell } from './api';
+import type { SwellData } from 'types/swell';
+export declare function getContentModel(swell: Swell, name: string): Promise<any>;
+export declare function getContentList(swell: Swell, type: string, query?: SwellData): Promise<any>;
+export declare function getContentEntry(swell: Swell, type: string, id: string, query?: SwellData): Promise<any>;
+export declare function getPage(swell: Swell, id: string, query?: object): Promise<any>;
+export declare function getBlogs(swell: Swell, query?: object): Promise<any>;
+export declare function getBlog(swell: Swell, id: string, query?: object): Promise<any>;

package/dist/src/easyblocks/config.d.ts

@@ -0,0 +1,136 @@
+import { SwellTheme } from '../theme';
+import type { Backend } from '@swell/easyblocks-core';
+import type { SwellThemeConfig, ThemeGlobals, ThemeLayoutSectionGroupConfig, ThemePageSectionSchema, ThemeSectionConfig } from 'types/swell';
+export declare function getEasyblocksPropsFromThemeConfigs(theme: SwellTheme, themeConfigs: SwellThemeConfig[], pageId: string): Promise<{
+    pageTemplate: string | import("types/swell").ThemePageTemplateConfig;
+    allSections: import("types/swell").ThemeSectionSchema[];
+    pageSections: ThemeSectionConfig[];
+    layoutSectionGroups: ThemeLayoutSectionGroupConfig[];
+}>;
+export declare function getEasyblocksPagePropsWithConfigs(themeGlobals: ThemeGlobals, allSections: ThemePageSectionSchema[], pageSections: ThemeSectionConfig[], layoutSectionGroups: ThemeLayoutSectionGroupConfig[], pageId: string): {
+    easyblocksConfig: {
+        components: any[];
+        templates: any[];
+        backend: Backend;
+        hideCloseButton: boolean;
+        allowSave: boolean;
+        readOnly: boolean;
+        locales: {
+            code: string;
+            isDefault: boolean;
+        }[];
+        types: {
+            swell_boolean: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_color: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_color_scheme: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_color_scheme_group: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_font: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_header: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_icon: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_lookup: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_menu: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_url: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_number: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_select: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_short_text: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_long_text: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_editor: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_file: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+            swell_image: {
+                type: string;
+                widget: {
+                    id: string;
+                };
+            };
+        };
+        tokens: {
+            colors: never[];
+            fonts: never[];
+        };
+    };
+};
+export declare function getEasyblocksComponentDefinitions(props: {
+    allSections: ThemePageSectionSchema[];
+    layoutSectionGroups: ThemeLayoutSectionGroupConfig[];
+}, getComponent: (type: string, data?: any) => any): any;
+export declare function getEasyblocksBackend(): Backend;

package/dist/src/easyblocks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './config';
+export { getThemeSettingsFromProps, getSectionSettingsFromProps, } from './utils';

package/dist/src/easyblocks/utils.d.ts

@@ -0,0 +1,36 @@
+import { SwellTheme } from '../theme';
+import type { SwellRecord, SwellThemeConfig, ThemeLayoutSectionGroupConfig, ThemeSectionConfig, ThemeSectionGroup, ThemeSectionSchema, ThemeSettingFieldSchema } from 'types/swell';
+export declare function getPageTemplate(theme: SwellTheme, pageId: string): Promise<string | import("types/swell").ThemePageTemplateConfig>;
+export declare function getAllSections(theme: SwellTheme, themeConfigs: SwellThemeConfig[]): Promise<ThemeSectionSchema[]>;
+export declare function getPageSections(theme: SwellTheme, sectionGroup: ThemeSectionGroup | SwellRecord, getSectionSchemaHandler?: any): Promise<ThemeSectionConfig[]>;
+export declare function getLayoutSectionGroups(theme: SwellTheme, themeConfigs: SwellThemeConfig[]): Promise<ThemeLayoutSectionGroupConfig[]>;
+export declare function getSectionSchema(theme: SwellTheme, sectionName: string): Promise<ThemeSectionSchema | undefined>;
+export declare function renderTemplateSchema(theme: SwellTheme, config: SwellThemeConfig): Promise<any>;
+export declare function filterSectionConfig(config: SwellRecord, themeConfigs: SwellThemeConfig[]): boolean;
+export declare function filterAllLayoutSectionGroupConfigs(config: SwellRecord, themeConfigs: SwellThemeConfig[]): any;
+export declare function filterLayoutSectionGroupConfig(config: SwellRecord, themeConfigs: SwellThemeConfig[], type: string): boolean;
+export declare function isJsonOrLiquidConfig(config: SwellRecord, themeConfigs: SwellThemeConfig[]): boolean;
+export declare function schemaToEasyblocksProps(field: ThemeSettingFieldSchema): {
+    type: string;
+    description: string | undefined;
+    defaultValue: any;
+    isLabelHidden: boolean;
+    layout: string;
+    params: ThemeSettingFieldSchema;
+} | {
+    type: string;
+    defaultValue: string;
+    description: string | undefined;
+    isLabelHidden: boolean;
+    layout: string;
+    params: ThemeSettingFieldSchema;
+};
+export declare function schemaToEasyblocksValue(fields: ThemeSettingFieldSchema[] | undefined, fieldId: string, value: any): any;
+export declare function getThemeSettingsFromProps(props: any, editorSchema: any): any;
+export declare function getSectionSettingsFromProps(props: any, sectionSchema: any): {
+    settings: any;
+    blocks: any;
+} | {
+    settings?: undefined;
+    blocks?: undefined;
+};

package/dist/src/fonts.d.ts

@@ -0,0 +1,6 @@
+import type { ThemeFontConfig } from '../types/swell';
+/**
+ * Map of all fonts supported by Swell.
+ */
+export declare const fontMap: Array<ThemeFontConfig>;
+export declare const systemFonts: string[];