@swell/apps-sdk 1.0.190 → 2.0.0-alpha.0

package/dist/src/api.d.ts

@@ -1,96 +0,0 @@
-import qs from 'qs';
-import type { SwellClient } from 'swell-js';
-import type { SwellApiParams, SwellAppConfig, SwellErrorOptions, SwellMenu, SwellData, SwellAppShopifyCompatibilityConfig } from '../types/swell';
-import type { CFThemeEnv, CFWorkerContext } from '../types/cloudflare';
-export * from './resources';
-export * from './resources/index';
-export declare class Swell {
-    url: URL;
-    headers: Record<string, string | undefined>;
-    swellHeaders: Record<string, string | undefined>;
-    queryParams: qs.ParsedQs;
-    workerCtx?: CFWorkerContext;
-    workerEnv?: CFThemeEnv;
-    config?: SwellAppConfig;
-    shopifyCompatibilityConfig?: SwellAppShopifyCompatibilityConfig;
-    backend?: SwellBackendAPI;
-    storefront: SwellClient<'snake'>;
-    storefrontContext: SwellData;
-    instanceId: string;
-    isPreview: boolean;
-    isEditor: boolean;
-    sentResponse: boolean;
-    storefront_url?: string;
-    private resourceLoadingIndicator?;
-    constructor(params: SwellApiParams);
-    static formatHeaders(serverHeaders?: Headers | Record<string, string | undefined>): {
-        headers: Record<string, string | undefined>;
-        swellHeaders: Record<string, string | undefined>;
-    };
-    static formatQueryParams(queryParams?: URLSearchParams | Record<string, string | undefined>): qs.ParsedQs;
-    /**
-     * Checks if cache bypass is requested via X-Cache-Bypass header
-     */
-    private shouldBypassCache;
-    /**
-     * Returns fields from the current account that may affect requests.
-     * Currently, only the 'group' field is returned.
-     * It is preferable to use the account_id from storefrontContext rather than the swell-session cookie, as the cookie contains a lot of other data
-     * This increases the overall cache size
-     */
-    private getAccountCacheKey;
-    /**
-     * Fetches a resource.
-     * First attempts to fetch from cache.
-     */
-    getCachedResource<T>(key: string, args: unknown[], handler: () => T | Promise<T>, isCacheble?: boolean): Promise<T | undefined>;
-    getAppSettings(): Promise<SwellData>;
-    getStorefrontSettings(force?: boolean): Promise<SwellData>;
-    getStorefrontMenus(): SwellMenu[];
-    getStorefrontLocalization(): {
-        locale: string;
-        currency: string;
-    };
-    get<T = SwellData>(...args: Parameters<SwellBackendAPI['get']>): Promise<T | undefined>;
-    put<T = SwellData>(...args: Parameters<SwellBackendAPI['put']>): Promise<T | undefined>;
-    post<T = SwellData>(...args: Parameters<SwellBackendAPI['post']>): Promise<T | undefined>;
-    delete<T = SwellData>(...args: Parameters<SwellBackendAPI['delete']>): Promise<T | undefined>;
-    /**
-     * Sets a loading handler to be called when a storefront resource is loading.
-     */
-    isLoading(loading?: boolean): void;
-    private getStorefrontInstance;
-    /**
-     * Initializes resources passed in from the server via request headers.
-     */
-    private initStorefrontContext;
-    private isStorefrontRequestCacheable;
-    private getCacheableStorefrontRequestHandler;
-    /**
-     * Caches client resources in memory.
-     */
-    private getResourceCache;
-    /**
-     * Caches client storefront API requests in memory.
-     */
-    private getRequestCache;
-}
-export declare class SwellBackendAPI {
-    apiHost: string;
-    apiAuth: string;
-    constructor({ storeId, accessToken, apiHost, }: {
-        storeId: string;
-        accessToken: string;
-        apiHost?: string;
-    });
-    makeRequest<T>(method: string, url: string, data?: object): Promise<T>;
-    stringifyQuery(queryObject: object, prefix?: string): string;
-    get<T = SwellData>(url: string, query?: SwellData): Promise<T>;
-    put<T = SwellData>(url: string, data: SwellData): Promise<T>;
-    post<T = SwellData>(url: string, data: SwellData): Promise<T>;
-    delete<T = SwellData>(url: string, data?: SwellData): Promise<T>;
-}
-export declare class SwellError extends Error {
-    status: number;
-    constructor(message: string, options?: SwellErrorOptions);
-}

package/dist/src/cache/cache.d.ts

@@ -1,41 +0,0 @@
-import { type CreateCacheOptions as OriginalCreateCacheOptions } from 'cache-manager';
-import type { CFWorkerKV, CFWorkerContext } from 'types/cloudflare';
-export type CreateCacheOptions = OriginalCreateCacheOptions & {
-    kvStore?: CFWorkerKV;
-    workerCtx?: CFWorkerContext;
-};
-/**
- * Cache supports memory or KV
- * The KV layer supports namespacing and compression
- */
-export declare class Cache {
-    private client;
-    private workerCtx?;
-    constructor(options?: CreateCacheOptions);
-    /**
-     * Always fetches fresh data and updates cache
-     * Deduplicates concurrent requests with the same key
-     *
-     * @param key Cache key
-     * @param fetchFn Function to fetch fresh data
-     * @param ttl Time to live in milliseconds (default: DEFAULT_SWR_TTL)
-     * @param isCacheable Whether to store result in cache (default: true)
-     */
-    fetch<T>(key: string, fetchFn: () => T | Promise<T>, ttl?: number, isCacheable?: boolean): Promise<T>;
-    /**
-     * Fetch cache using SWR (stale-while-revalidate)
-     *
-     * This will always return the cached value immediately if exists
-     */
-    fetchSWR<T>(key: string, fetchFn: () => T | Promise<T>, ttl?: number, isCacheble?: boolean): Promise<T>;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T, ttl?: number): Promise<T>;
-    flush(key: string): Promise<void>;
-    /**
-     * Flushes the entire cache.
-     *
-     * __WARNING__: If the cache store is shared among many cache clients,
-     *              this will flush entries for other clients.
-     */
-    flushAll(): Promise<void>;
-}

package/dist/src/cache/cf-worker-kv-keyv-adapter.d.ts

@@ -1,18 +0,0 @@
-import type { KeyvStoreAdapter } from 'keyv';
-import type { CFWorkerKV } from 'types/cloudflare';
-/**
- * CloudFlare Workers KV adapter for Keyv.
- * Includes namespacing to prevent conflicts within shared storage.
- */
-export declare class CFWorkerKVKeyvAdapter implements KeyvStoreAdapter {
-    private store;
-    namespace: string;
-    opts: unknown;
-    constructor(store: CFWorkerKV);
-    has(key: string): Promise<boolean>;
-    get<T>(key: string): Promise<T | undefined>;
-    set(key: string, value: string, ttl?: number): Promise<void>;
-    delete(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-    on(_event: string, _listener: (...args: unknown[]) => void): CFWorkerKVKeyvAdapter;
-}

package/dist/src/cache/constants.d.ts

@@ -1,7 +0,0 @@
-export declare const SECOND = 1000;
-export declare const MINUTE: number;
-export declare const HOUR: number;
-export declare const DAY: number;
-export declare const YEAR: number;
-export declare const MAX_TTL: number;
-export declare const SHORT_TTL: number;

package/dist/src/cache/content-cache.d.ts

@@ -1,21 +0,0 @@
-import { type CreateCacheOptions } from './cache';
-export interface ContentCacheOptions extends CreateCacheOptions {
-    defaultTtl?: number;
-}
-/**
- * Simple content cache exposing only get/set operations.
- * Designed for caching versioned, immutable content like rendered assets.
- */
-export declare class ContentCache {
-    private cache;
-    private defaultTtl;
-    constructor(options?: ContentCacheOptions);
-    /**
-     * Get content from cache
-     */
-    get<T = any>(key: string): Promise<T | undefined>;
-    /**
-     * Set content in cache
-     */
-    set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
-}

package/dist/src/cache/html-cache/html-cache-backend.d.ts

@@ -1,64 +0,0 @@
-/**
- * Represents a standardized, serializable cache entry.
- * This object is used to pass data between the core caching logic and the
- * storage backend, ensuring that any backend can store and retrieve the
- * necessary information consistently.
- */
-export interface CachedEntry {
-    /** The HTTP status code of the original response (e.g., 200). */
-    status: number;
-    /** The HTTP status text of the original response (e.g., "OK"). */
-    statusText: string;
-    /**
-     * A record of the original response headers.
-     * Stored as a plain object for easy JSON serialization.
-     */
-    headers: Record<string, string>;
-    /** The response body, stored as a UTF-8 string. */
-    body: string;
-    /** The ISO 8601 timestamp string indicating when the entry was created. */
-    cacheTimeISO: string;
-    /** The Time-to-Live (TTL) for this entry in seconds. */
-    ttl: number;
-    /** The Stale-While-Revalidate (SWR) period for this entry in seconds. */
-    swr: number;
-    /**
-     * The ETag from the original response, if present.
-     * Used for handling 'If-None-Match' conditional requests.
-     */
-    etag?: string;
-    /**
-     * The Last-Modified date from the original response, if present.
-     * Used for handling 'If-Modified-Since' conditional requests.
-     * Should be stored as a UTC string.
-     */
-    lastModifiedUTC?: string;
-}
-/**
- * Defines the contract for a storage backend.
- * Any class implementing this interface can be used as a storage layer
- * for the HtmlCache, allowing for a pluggable architecture.
- */
-export interface CacheBackend {
-    /**
-     * Reads a cached entry from the storage.
-     * @param key The unique identifier for the cache entry.
-     * @returns A promise that resolves to the `CachedEntry` if found, or `null` otherwise.
-     */
-    read(key: string): Promise<CachedEntry | null>;
-    /**
-     * Writes a cache entry to the storage.
-     * @param key The unique identifier for the cache entry.
-     * @param entry The `CachedEntry` object to store.
-     * @param hardExpireSeconds The total lifetime of the entry in the storage system
-     * @returns A promise that resolves when the write operation is complete.
-     */
-    write(key: string, entry: CachedEntry, hardExpireSeconds: number): Promise<void>;
-    /**
-     * Deletes a cache entry from the storage.
-     * This is optional but recommended for cache invalidation.
-     * @param key The unique identifier for the cache entry to delete.
-     * @returns A promise that resolves when the delete operation is complete.
-     */
-    delete?(key: string): Promise<void>;
-}

package/dist/src/cache/html-cache/html-cache-factory.d.ts

@@ -1,9 +0,0 @@
-import type { KVNamespace } from '@cloudflare/workers-types';
-import { HtmlCache, type CacheRules } from './html-cache';
-export type HtmlCacheEnv = {
-    NAMESPACE?: KVNamespace;
-    HTML_CACHE_EPOCH?: string;
-    HTML_CACHE_BACKEND?: 'kv' | 'worker';
-    HTML_CACHE_RULES?: CacheRules;
-};
-export declare function getHtmlCache(env?: HtmlCacheEnv, cacheRules?: CacheRules): HtmlCache | null;

package/dist/src/cache/html-cache/html-cache-kv.d.ts

@@ -1,38 +0,0 @@
-import type { CacheBackend, CachedEntry } from './html-cache-backend';
-type KVNamespace = import('@cloudflare/workers-types').KVNamespace;
-export type KVCacheBackendOptions = {
-    /**
-     * Optional key prefix to help with namespacing and easier debugging.
-     * Example: "html" -> "html:<hash>"
-     */
-    prefix?: string;
-    /**
-     * If true (default), the logical key will be hashed with md5 to ensure
-     * it stays under the 512-byte KV key length limit and is URL-safe.
-     */
-    hashKeys?: boolean;
-    /**
-     * Safety headroom against the 25 MiB KV value limit.
-     * Default ~24.5 MiB to leave some slack for encoding overhead.
-     */
-    maxValueBytes?: number;
-};
-/**
- * Cloudflare KV implementation of CacheBackend.
- * Stores the entire CachedEntry as a compact JSON blob (value),
- * and a tiny summary in metadata for potential future use.
- */
-export declare class KVCacheBackend implements CacheBackend {
-    private readonly kv;
-    private readonly prefix;
-    private readonly hashKeys;
-    private readonly maxValueBytes;
-    constructor(kv: KVNamespace, opts?: KVCacheBackendOptions);
-    read(key: string): Promise<CachedEntry | null>;
-    write(key: string, entry: CachedEntry, hardExpireSeconds: number): Promise<void>;
-    delete(key: string): Promise<void>;
-    private makeKey;
-    private assertSize;
-    private approxUtf8Bytes;
-}
-export {};

package/dist/src/cache/html-cache/html-cache-worker.d.ts

@@ -1,8 +0,0 @@
-import type { CacheBackend, CachedEntry } from './html-cache-backend';
-export declare class WorkerCacheBackend implements CacheBackend {
-    private readonly cacheName;
-    constructor(epoch: string);
-    read(key: string): Promise<CachedEntry | null>;
-    write(key: string, entry: CachedEntry, _hardExpireSeconds: number): Promise<void>;
-    delete(key: string): Promise<void>;
-}

package/dist/src/cache/html-cache/html-cache.d.ts

@@ -1,120 +0,0 @@
-import type { CacheBackend, CachedEntry } from './html-cache-backend';
-/**
- * Configuration for path-specific cache behavior.
- *
- * Paths support wildcards:
- *   - `*` matches any characters except `/`
- *   - `**` matches any characters including `/`
- *
- * Examples: `/account/*`, `/api/**`, `*.json`
- *
- * First matching rule wins.
- */
-export interface PathRule {
-    path: string;
-    /** Time-to-live in seconds */
-    ttl?: number;
-    /** Stale-while-revalidate in seconds */
-    swr?: number;
-    /** If true, skip caching for this path */
-    skip?: boolean;
-    /**
-     * Optional list of allowed Content-Types for caching.
-     *
-     * If provided, responses whose Content-Type starts with one of these values are cacheable.
-     *
-     * If omitted, defaults to only allowing `text/html`.
-     */
-    contentTypes?: string[];
-}
-export interface CacheRules {
-    defaults: {
-        live: {
-            ttl: number;
-            swr: number;
-        };
-        preview: {
-            ttl: number;
-            swr: number;
-        };
-    };
-    pathRules?: PathRule[];
-}
-export declare const DEFAULT_CACHE_RULES: CacheRules;
-interface PathRuleInner extends PathRule {
-    regex: RegExp;
-}
-interface CacheRulesInner {
-    defaults: {
-        live: {
-            ttl: number;
-            swr: number;
-        };
-        preview: {
-            ttl: number;
-            swr: number;
-        };
-    };
-    pathRules?: PathRuleInner[];
-}
-type DeploymentMode = 'live' | 'preview';
-export interface CacheResult {
-    found: boolean;
-    stale?: boolean;
-    response?: Response;
-    cacheable?: boolean;
-    age?: number;
-    notModified?: boolean;
-    conditional304?: Response;
-}
-/**
- * Contains all the storage-agnostic HTML caching logic.
- * It determines what to cache, for how long, how to build cache keys,
- * and how to construct client responses, while delegating the actual
- * read/write operations to a pluggable backend.
- */
-export declare class HtmlCache {
-    protected epoch: string;
-    protected backend: CacheBackend;
-    protected cacheRules: CacheRulesInner;
-    constructor(epoch: string, backend: CacheBackend, cacheRules?: CacheRules);
-    /**
-     * Converts wildcard pattern to regex and tests against path.
-     *
-     * - `*` matches any characters except `/`
-     * - `**` matches any characters including `/`
-     */
-    protected convertPathToRegex(pattern: string): RegExp;
-    get(request: Request): Promise<CacheResult | null>;
-    getWithConditionals(request: Request): Promise<CacheResult | null>;
-    put(request: Request, response: Response): Promise<void>;
-    delete(requestOrKey: Request | string): Promise<void>;
-    canReadFromCache(request: Request): boolean;
-    canWriteToCache(request: Request, response: Response): boolean;
-    createRevalidationRequest(request: Request): Request;
-    protected buildClientResponse(entry: CachedEntry, isStale: boolean, age: number): Response;
-    protected buildCacheKey(request: Request): string;
-    protected checkNotModified(ifModifiedSince: string | null, ifNoneMatch: string | null, lastModified: string | null, etag: string | null): boolean;
-    protected ifNoneMatchMatches(ifNoneMatch: string | null, etag: string | null): boolean;
-    protected quoteETag(value: string): string;
-    protected sanitizeClientHeaders(headers: Headers): void;
-    getCacheKeyHeaders(headers: Headers): Headers;
-    protected generateVersionHash(headers: Headers): string;
-    protected extractSwellData(cookie: string | null): Record<string, unknown>;
-    protected isRequestCacheable(request: Request): boolean;
-    protected isResponseCacheable(response: Response, matchedRule?: PathRule): boolean;
-    protected getDeploymentMode(headers: Headers): DeploymentMode;
-    protected getTTLForRequest(request: Request): number;
-    protected getSWRForRequest(request: Request): number;
-    protected getEntryAge(entry: CachedEntry): number;
-    protected normalizeHeaders(headers: Headers): Record<string, string>;
-    protected resolvePathRule(request: Request): {
-        rule?: PathRule;
-        mode: 'live' | 'preview';
-        effectiveTTL: number;
-        effectiveSWR: number;
-        skip: boolean;
-    };
-    protected normalizeSearchParams(searchParams: URLSearchParams): string;
-}
-export {};

package/dist/src/cache/html-cache/index.d.ts

@@ -1,4 +0,0 @@
-export type { CacheResult, CacheRules, PathRule } from './html-cache';
-export { HtmlCache, DEFAULT_CACHE_RULES } from './html-cache';
-export { getHtmlCache } from './html-cache-factory';
-export type { HtmlCacheEnv } from './html-cache-factory';

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

@@ -1,9 +0,0 @@
-export { Cache } from './cache';
-export { RequestCache } from './request-cache';
-export { ResourceCache } from './resource-cache';
-export { ThemeCache } from './theme-cache';
-export { ThemeFileCache } from './theme-file-cache';
-export { ContentCache } from './content-cache';
-export type { ContentCacheOptions } from './content-cache';
-export type { ThemeFileCacheInterface, PutFilesResult, FileWarning, } from './theme-file-cache';
-export type { KVFlavor } from './kv-variety';

package/dist/src/cache/kv-variety.d.ts

@@ -1,10 +0,0 @@
-import type { CFThemeEnv } from '../../types/cloudflare';
-export interface ClientKV {
-    get(keys: string[]): Promise<Map<string, string | null>>;
-    put(key: string, value: string, metadata?: Record<string, any>): Promise<void>;
-}
-export type KVFlavor = 'cf' | 'miniflare' | 'memory';
-/**
- * Factory function to create appropriate KV implementation
- */
-export declare function createClientKV(env?: CFThemeEnv, flavor?: KVFlavor): ClientKV;

package/dist/src/cache/request-cache.d.ts

@@ -1,4 +0,0 @@
-import { Cache, type CreateCacheOptions } from './cache';
-export declare class RequestCache extends Cache {
-    constructor(options?: CreateCacheOptions);
-}

package/dist/src/cache/resource-cache.d.ts

@@ -1,4 +0,0 @@
-import { Cache, type CreateCacheOptions } from './cache';
-export declare class ResourceCache extends Cache {
-    constructor(options?: CreateCacheOptions);
-}

package/dist/src/cache/theme-cache.d.ts

@@ -1,4 +0,0 @@
-import { Cache, type CreateCacheOptions } from './cache';
-export declare class ThemeCache extends Cache {
-    constructor(options?: CreateCacheOptions);
-}

package/dist/src/cache/theme-file-cache.d.ts

@@ -1,87 +0,0 @@
-import type { SwellThemeConfig } from '../../types/swell';
-import type { CFThemeEnv } from '../../types/cloudflare';
-import type { KVFlavor } from './kv-variety';
-/**
- * Main interface for theme file storage operations
- */
-export interface ThemeFileCacheInterface {
-    /**
-     * Load files for given configs, intelligently batching to avoid 413 errors
-     * Returns new configs with file_data populated
-     */
-    getFiles(configs: SwellThemeConfig[]): Promise<SwellThemeConfig[]>;
-    /**
-     * Store files, checking existence first to avoid redundant writes
-     * Validates file sizes and returns detailed results
-     */
-    putFiles(configs: SwellThemeConfig[]): Promise<PutFilesResult>;
-}
-/**
- * Result of a putFiles operation
- */
-export interface PutFilesResult {
-    /** Number of files successfully written to storage */
-    written: number;
-    /** Number of files skipped due to size violations */
-    skipped: number;
-    /** Number of files skipped because they already exist */
-    skippedExisting: number;
-    /** Detailed warnings about file size issues */
-    warnings: FileWarning[];
-}
-/**
- * Warning about a file that triggered size thresholds
- */
-export interface FileWarning {
-    /** Hash identifier of the file */
-    hash: string;
-    /** Path of the file for logging */
-    filePath: string;
-    /** Size of the file in bytes */
-    size: number;
-    /** Reason for the warning */
-    reason: 'warning_1mb' | 'rejected_5mb' | 'exceeded_25mb';
-    /** Action taken for this file */
-    action: 'stored' | 'rejected';
-}
-/**
- * Theme file storage implementation
- * Manages efficient batch operations for theme files in KV storage
- */
-export declare class ThemeFileCache implements ThemeFileCacheInterface {
-    private kv;
-    private maxBatchSize;
-    constructor(env?: CFThemeEnv, flavor?: KVFlavor);
-    /**
-     * Build a KV storage key from a file hash
-     */
-    private buildKey;
-    /**
-     * Extract hash from a KV storage key
-     */
-    private extractHashFromKey;
-    /**
-     * Plan GET batches based on file sizes to avoid 413 errors
-     * Uses round-robin distribution for even batch sizes
-     */
-    private planGetBatches;
-    /**
-     * Load a single batch from KV storage
-     */
-    private loadBatch;
-    /**
-     * Merge batch results with original configs
-     */
-    private mergeResults;
-    getFiles(configs: SwellThemeConfig[]): Promise<SwellThemeConfig[]>;
-    /**
-     * Validate file sizes and categorize by threshold
-     */
-    private validateFiles;
-    /**
-     * Check which files already exist in KV storage
-     * Uses batch planning to avoid 413 errors when checking existence
-     */
-    private checkExistence;
-    putFiles(configs: SwellThemeConfig[]): Promise<PutFilesResult>;
-}

package/dist/src/compatibility/drops/all_products.d.ts

@@ -1,10 +0,0 @@
-import { Drop } from 'liquidjs';
-import { type ShopifyResource } from '../shopify-objects';
-import type { ShopifyCompatibility } from '../shopify';
-import type { ShopifyProduct as ShopifyProductType } from 'types/shopify';
-export default class AllProductsDrop extends Drop {
-    #private;
-    constructor(instance: ShopifyCompatibility);
-    liquidMethodMissing(key: unknown): unknown;
-    getProduct(slug: string): ShopifyResource<ShopifyProductType> | null;
-}

package/dist/src/compatibility/drops/articles.d.ts

@@ -1,10 +0,0 @@
-import { Drop } from 'liquidjs';
-import { type ShopifyResource } from '../shopify-objects';
-import type { ShopifyCompatibility } from '../shopify';
-import type { ShopifyArticle as ShopifyArticleType } from 'types/shopify';
-export default class ArticlesDrop extends Drop {
-    #private;
-    constructor(instance: ShopifyCompatibility);
-    liquidMethodMissing(key: unknown): unknown;
-    getArticle(slug: string): ShopifyResource<ShopifyArticleType>;
-}

package/dist/src/compatibility/drops/blogs.d.ts

@@ -1,10 +0,0 @@
-import { Drop } from 'liquidjs';
-import { type ShopifyResource } from '../shopify-objects';
-import type { ShopifyCompatibility } from '../shopify';
-import type { ShopifyBlog as ShopifyBlogType } from 'types/shopify';
-export default class BlogsDrop extends Drop {
-    #private;
-    constructor(instance: ShopifyCompatibility);
-    liquidMethodMissing(key: unknown): unknown;
-    getBlog(slug: string): ShopifyResource<ShopifyBlogType>;
-}

package/dist/src/compatibility/drops/collections.d.ts

@@ -1,19 +0,0 @@
-import { Drop } from 'liquidjs';
-import { SwellStorefrontCollection } from '@/resources';
-import { type ShopifyResource } from '../shopify-objects';
-import type { ShopifyCompatibility } from '../shopify';
-import type { ShopifyCollection as ShopifyCollectionType } from 'types/shopify';
-declare class CollectionsDrop extends Drop {
-    #private;
-    constructor(instance: ShopifyCompatibility);
-    liquidMethodMissing(key: unknown): unknown;
-    getCollection(slug: string): ShopifyResource<ShopifyCollectionType>;
-    getAllCollection(): ShopifyResource<ShopifyCollectionType>;
-    getAllCollectionsSize(): Promise<number> | number;
-}
-export default class Collections extends SwellStorefrontCollection<ShopifyCollectionType> {
-    #private;
-    constructor(instance: ShopifyCompatibility);
-    toLiquid(): CollectionsDrop;
-}
-export {};

package/dist/src/compatibility/drops/image-src.d.ts

@@ -1,15 +0,0 @@
-import { Drop } from 'liquidjs';
-import type { ShopifyImageSrc } from 'types/shopify';
-export declare class ImageSrcDrop extends Drop implements ShopifyImageSrc {
-    url: string;
-    width: number;
-    height: number;
-    constructor(url: string, width: number, height: number);
-    toString(): string;
-    toJSON(): string;
-    toLiquid(): {
-        url: string;
-        width: number;
-        height: number;
-    };
-}

package/dist/src/compatibility/drops/image.d.ts

@@ -1,29 +0,0 @@
-import { Drop } from 'liquidjs';
-import type { StorefrontResource } from '@/resources';
-import type { SwellData, SwellRecord } from 'types/swell';
-import type { ShopifyImage, ShopifyImagePresentation, ShopifyImageSrc, ShopifyVariant } from 'types/shopify';
-interface ShopifyImageOptions {
-    media_type?: 'image';
-    position?: number;
-    product_id?: number;
-}
-export declare class ImageDrop extends Drop implements ShopifyImage {
-    id: number;
-    alt: string;
-    src: ShopifyImageSrc;
-    media_type?: 'image' | undefined;
-    preview_image?: ShopifyImage | undefined;
-    presentation?: ShopifyImagePresentation | undefined;
-    aspect_ratio: number;
-    'attached_to_variant?': boolean | undefined;
-    width: number;
-    height: number;
-    position?: number | undefined;
-    product_id?: number | undefined;
-    variants?: ShopifyVariant[] | undefined;
-    constructor(image: SwellData, options?: ShopifyImageOptions, product?: StorefrontResource | SwellRecord, variant?: StorefrontResource | SwellRecord);
-    toString(): string;
-    [Symbol.toPrimitive](): string;
-    toJSON(): string;
-}
-export {};