import { type SwishI18n } from "@swishapp/i18n";
import { AjaxApiClient } from "./ajax-api/ajax-api-client";
import { PlacementSpec } from "./dom/create-placement";
import { createElementLocator, createLocationObserver } from "./dom/dom-utils";
import { EventBus } from "./events/event-bus";
import { Intents } from "./intents/intents";
import { SwishOptionsInput } from "./options/swish-options";
import { SwishOptions } from "./options/types";
import { SwishQuery } from "./query";
import { computed, effect, signal } from "./state";
import { StorefrontApiClient } from "./storefront-api/storefront-api-client";
import { SwishApi } from "./swish-api/swish-api-client";
import { SwishUiElement } from "./swish-ui/swish-ui-element";
import { RequireUiComponentOptions } from "./swish-ui/types";
import { copyToClipboard } from "./utils/copy-to-clipboard";
export declare const VERSION: string;
export declare const swishSdkUrl: string;
export declare const createSwish: (optionsInput: SwishOptionsInput) => Promise<SwishApp>;
declare class SwishApp {
    private readonly swishApi;
    private readonly swishApiPublisher;
    private readonly storefrontApi;
    private readonly ajaxApi;
    private readonly ajaxApiPublisher;
    private readonly swishOptions;
    private readonly swishUi;
    private readonly _i18n;
    readonly events: EventBus;
    readonly intents: Intents;
    readonly query: SwishQuery;
    constructor(options: SwishOptions);
    get options(): SwishOptions;
    get storefrontContext(): import("./swish").StorefrontContext;
    get api(): SwishApi;
    get storefront(): StorefrontApiClient;
    get ajax(): AjaxApiClient;
    get i18n(): SwishI18n;
    get shopUrl(): string;
    readonly dom: {
        createElementLocator: typeof createElementLocator;
        createLocationObserver: typeof createLocationObserver;
        createPlacement: (spec: PlacementSpec) => {
            mount(): void;
            unmount(): void;
        };
    };
    readonly ui: {
        createElement: (name: string, options?: RequireUiComponentOptions) => Promise<SwishUiElement>;
    };
    readonly utils: {
        copyToClipboard: typeof copyToClipboard;
        createShareUrl: (args: {
            publicListId: string;
        }) => URL;
    };
    readonly state: {
        itemContext: (source: HTMLElement | Location) => import("@preact/signals-core").Signal<import("./state").ItemContext>;
        itemState: (context: import("@preact/signals-core").Signal<import("./state").ItemContext>) => import("@preact/signals-core").ReadonlySignal<{
            error: import("@swishapp/api-client").ApiError | null;
            status: string;
            savedItemId: string | null;
            loading: boolean;
            submitting: boolean;
            saved: boolean;
            saving: boolean;
            unsaving: boolean;
        }> & {
            save: () => Promise<void>;
            unsave: () => Promise<void>;
            update: () => Promise<void>;
            toggle: () => Promise<void>;
            dispose: () => void;
        };
        itemCount: () => import("@preact/signals-core").ReadonlySignal<{
            count: number;
            loading: boolean;
            error: import("@swishapp/api-client").ApiError | null;
        }>;
        swishQuery: <TResponse extends import("@swishapp/api-client").ApiResponse<any> | import("@swishapp/api-client").PaginatedApiResponse<any>, TVariables>(fetch: import("./state").FetchFn<TResponse, TVariables>, options?: {
            variables?: import("@preact/signals-core").Signal<TVariables>;
            skip?: import("@preact/signals-core").Signal<boolean>;
            refetch?: import("./swish").EventName[];
        }) => {
            data: import("@preact/signals-core").Signal<(TResponse extends {
                data: infer D;
            } ? D : never) | null>;
            pageInfo: import("@preact/signals-core").Signal<import("@swishapp/api-client").PageInfo | null>;
            error: import("@preact/signals-core").Signal<import("@swishapp/api-client").ApiError | null>;
            loading: import("@preact/signals-core").Signal<boolean>;
            refetching: import("@preact/signals-core").ReadonlySignal<boolean>;
        };
        effect: typeof effect;
        signal: typeof signal;
        computed: typeof computed;
    };
}
export type * from "@swishapp/api-client/2026-04";
export type { SwishI18n } from "@swishapp/i18n";
export type * from "./ajax-api/ajax-api-client";
export type { EventName } from "./events/event-bus";
export type * from "./intents/types";
export type { SwishOptionsInput } from "./options/swish-options";
export type * from "./options/types";
export type * from "./storefront-api/storefront-api-client";
export type { Ref, SwishUiElement } from "./swish-ui/swish-ui-element";
export type { ListSelectOptions, ListSelectSubmitData, QuickBuyOptions, QuickBuySubmitData, Toast, ToastManager, UnsaveAlertOptions, UnsaveAlertSubmitData, VariantSelectOptions, VariantSelectSubmitData, } from "./swish-ui/types";
export type { Product, ProductVariant, SwishUiElementSpec, SwishUiManifest, } from "./types";
export { buildShareListUrl } from "./utils/build-share-list-url";
export { copyToClipboard } from "./utils/copy-to-clipboard";
export { getSwishQueryStorageKey } from "./query";
export type { SwishApp };
declare global {
    interface Window {
        Shopify?: {
            analytics?: {
                publish?: (event: string, data: Record<string, any>) => void;
            };
        };
        _SWISH_UI_VERSION?: string;
    }
    var _SWISH_UI_VERSION: string | undefined;
}