nuxt-convex-module 0.0.0

package/dist/runtime/nuxt/composables/use-async-query.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Nuxt-idiomatic data fetching for Convex queries.
+ *
+ * {@link useAsyncQuery} is a Vue/Nuxt-only addition (no `convex/react`
+ * counterpart — see PARITY.md): it marries Nuxt's `useAsyncData` model with
+ * Convex's live queries. During SSR the query runs over HTTP and the result is
+ * embedded in the Nuxt payload; after hydration the composable upgrades to the
+ * WebSocket subscription, so the page paints with server data and stays live —
+ * no loading flash, no client refetch.
+ *
+ * @module
+ */
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+import type { FunctionArgs, FunctionReference, FunctionReturnType } from 'convex/server';
+/**
+ * Request status of a {@link useAsyncQuery} call — mirrors Nuxt's
+ * `useAsyncData` statuses.
+ *
+ * @public
+ */
+export type AsyncQueryStatus = 'idle' | 'pending' | 'success' | 'error';
+/**
+ * Options for {@link useAsyncQuery}.
+ *
+ * @public
+ */
+export interface AsyncQueryOptions {
+    /**
+     * Key for the underlying `useAsyncData` entry (payload dedup across
+     * components). Defaults to a key derived from the query name and the
+     * initial args. Provide an explicit key when two call sites must not
+     * share a payload entry.
+     */
+    key?: string;
+    /**
+     * Fetch the query on the server during SSR and embed the result in the Nuxt
+     * payload. Set `false` to fetch on the client only.
+     *
+     * @default true
+     */
+    server?: boolean;
+    /**
+     * Mirror `useAsyncData`'s `lazy` option: don't block client-side navigation
+     * on the initial fetch.
+     *
+     * @default false
+     */
+    lazy?: boolean;
+    /**
+     * Upgrade to a live WebSocket subscription on the client. Set `false` for
+     * SSR + hydration *without* realtime updates — no WebSocket is opened for
+     * this query, and {@link AsyncQueryReturn.refresh | refresh} becomes the way
+     * to get fresh data.
+     *
+     * @default true
+     */
+    live?: boolean;
+    /**
+     * JWT to authenticate the SSR fetch, or a function resolving one. Defaults
+     * to the token the Better Auth server plugin prefetched for this request
+     * (when that integration is enabled); pass a value here to integrate any
+     * other server-side auth source. The client-side live subscription
+     * authenticates through the Convex client's own `setAuth` wiring.
+     */
+    token?: string | (() => string | null | Promise<string | null>);
+}
+/**
+ * Reactive result of {@link useAsyncQuery}. Also awaitable — `await
+ * useAsyncQuery(...)` blocks until the initial fetch settles, like
+ * `useAsyncData`.
+ *
+ * @public
+ */
+export interface AsyncQueryReturn<T> extends PromiseLike<AsyncQueryData<T>> {
+    /**
+     * The query result: the server-fetched value first, replaced by the live
+     * subscription's value once the client receives one. `undefined` while
+     * nothing has loaded (or while skipped).
+     */
+    data: ComputedRef<T | undefined>;
+    /** The initial-fetch or live-subscription error, `null` when none. */
+    error: ComputedRef<Error | null>;
+    /**
+     * Initial-fetch status. Live pushes don't churn it: once data exists it
+     * stays `'success'` unless the live subscription errors.
+     */
+    status: ComputedRef<AsyncQueryStatus>;
+    /**
+     * Re-run the one-shot fetch. With a live subscription (`live: true`) the
+     * server already pushes updates, so this is mainly for retrying after an
+     * error; with `live: false` it is the way to get fresh data.
+     */
+    refresh: (opts?: {
+        dedupe?: 'cancel' | 'defer';
+    }) => Promise<void>;
+}
+type AsyncQueryData<T> = Pick<AsyncQueryReturn<T>, 'data' | 'error' | 'status' | 'refresh'>;
+/**
+ * Load a Convex query the Nuxt way: fetched on the server during SSR,
+ * hydrated through the Nuxt payload, then seamlessly upgraded to a live
+ * WebSocket subscription on the client.
+ *
+ * Compared to {@link useQuery} (which renders `undefined` during SSR and
+ * fetches on the client), `useAsyncQuery` puts real data in the
+ * server-rendered HTML and never refetches it on hydration — the live
+ * subscription simply takes over. Compared to `preloadQuery` +
+ * `usePreloadedQuery`, no server route or prop-threading is needed.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { api } from '#convex/api'
+ *
+ * // SSR-rendered AND live:
+ * const { data: tasks, status, error } = useAsyncQuery(api.tasks.list, { completed: false })
+ *
+ * // SSR + hydration without a WebSocket (fetch-once pages):
+ * const { data: stats, refresh } = useAsyncQuery(api.stats.summary, {}, { live: false })
+ * </script>
+ * ```
+ *
+ * The Nuxt payload entry is keyed on the query name and the *initial* args
+ * (override with `options.key`). Reactive args are honored by the live
+ * subscription; the payload only matters for first paint.
+ *
+ * Pass `'skip'` as args (or a getter returning it) to pause the query — no
+ * fetch runs and no subscription opens until args become real.
+ *
+ * @param query - a `FunctionReference` for the public query to run, like
+ * `api.dir1.dir2.filename.func`.
+ * @param args - The arguments to the query function, or `'skip'`. Accepts a
+ * ref, computed, or getter for reactive args.
+ * @param options - {@link AsyncQueryOptions}.
+ * @returns An awaitable {@link AsyncQueryReturn} of `data` / `error` /
+ * `status` refs and a `refresh` function.
+ *
+ * @public
+ */
+export declare function useAsyncQuery<Query extends FunctionReference<'query'>>(query: Query, args?: MaybeRefOrGetter<FunctionArgs<Query> | 'skip'>, options?: AsyncQueryOptions): AsyncQueryReturn<FunctionReturnType<Query>>;
+/** Payload key for a query + initial args. Exported for tests. @internal */
+export declare function defaultAsyncQueryKey(queryName: string, initialArgs: unknown): string;
+/** @public */
+export declare const useConvexAsyncQuery: typeof useAsyncQuery;
+export {};

package/dist/runtime/nuxt/composables/use-async-query.js

@@ -0,0 +1,104 @@
+import { useAsyncData, useRuntimeConfig, useState } from "#app";
+import { computed, shallowRef, toValue } from "vue";
+import { getFunctionName, makeFunctionReference } from "convex/server";
+import { convexToJson, jsonToConvex } from "convex/values";
+import { useConvex } from "../../vue/client.js";
+import { useConvexQueries } from "../../vue/composables/use-queries.js";
+import { fetchQuery } from "../index.js";
+export function useAsyncQuery(query, args, options = {}) {
+  const { server = true, lazy = false, live = true, token } = options;
+  const queryReference = typeof query === "string" ? makeFunctionReference(query) : query;
+  const queryName = getFunctionName(queryReference);
+  const initialArgs = toValue(args) ?? {};
+  const key = options.key ?? defaultAsyncQueryKey(queryName, initialArgs);
+  const initialToken = useState("convex:initialToken", () => null);
+  const client = useConvex();
+  const deploymentUrl = import.meta.server ? useRuntimeConfig().public.convex.url : "";
+  const resolveToken = async () => {
+    const resolved = typeof token === "function" ? await token() : token ?? initialToken.value;
+    return resolved ?? void 0;
+  };
+  const asyncData = useAsyncData(
+    key,
+    async () => {
+      const currentArgs = toValue(args) ?? {};
+      if (currentArgs === "skip") {
+        return null;
+      }
+      if (import.meta.server) {
+        if (!deploymentUrl) {
+          throw new Error(
+            "`useAsyncQuery` could not fetch during SSR: no Convex deployment URL is configured. Set the `convex.url` module option or NUXT_PUBLIC_CONVEX_URL."
+          );
+        }
+        const value2 = await fetchQuery(queryReference, currentArgs, {
+          token: await resolveToken(),
+          url: deploymentUrl
+        });
+        return { value: convexToJson(value2) };
+      }
+      if (!client) {
+        throw new Error(
+          "`useAsyncQuery` could not fetch on the client: no Convex client is available. Is the `convex.url` module option (or NUXT_PUBLIC_CONVEX_URL) configured?"
+        );
+      }
+      const value = await client.query(queryReference, currentArgs);
+      return { value: convexToJson(value) };
+    },
+    {
+      server,
+      lazy,
+      deep: false,
+      // Skipped-at-setup queries start idle instead of "successfully null".
+      immediate: initialArgs !== "skip"
+    }
+  );
+  const payloadValue = computed(() => {
+    const entry = asyncData.data.value;
+    if (entry === null || entry === void 0) {
+      return void 0;
+    }
+    return jsonToConvex(entry.value);
+  });
+  const liveResults = !import.meta.server && live && client ? useConvexQueries(computed(() => {
+    const currentArgs = toValue(args) ?? {};
+    if (currentArgs === "skip") {
+      return {};
+    }
+    return {
+      query: { query: queryReference, args: currentArgs }
+    };
+  })) : shallowRef({});
+  const liveValue = computed(() => {
+    const result2 = liveResults.value["query"];
+    return result2 instanceof Error ? void 0 : result2;
+  });
+  const liveError = computed(() => {
+    const result2 = liveResults.value["query"];
+    return result2 instanceof Error ? result2 : null;
+  });
+  const data = computed(
+    () => liveValue.value !== void 0 ? liveValue.value : payloadValue.value
+  );
+  const error = computed(
+    () => liveError.value ?? asyncData.error.value ?? null
+  );
+  const status = computed(() => {
+    if (liveError.value) {
+      return "error";
+    }
+    if (liveValue.value !== void 0) {
+      return "success";
+    }
+    return asyncData.status.value;
+  });
+  const refresh = (opts) => asyncData.refresh(opts);
+  const result = { data, error, status, refresh };
+  const promise = Promise.resolve(asyncData).then(() => result);
+  return Object.assign(promise, result);
+}
+export function defaultAsyncQueryKey(queryName, initialArgs) {
+  const argsJson = initialArgs === "skip" ? '"skip"' : JSON.stringify(convexToJson(initialArgs ?? {}));
+  return `convex:${queryName}:${argsJson}`;
+}
+export const useConvexAsyncQuery = useAsyncQuery;

package/dist/runtime/nuxt/config.d.ts

@@ -0,0 +1,7 @@
+export declare function getConvexRuntimeConfig(): {
+    url: string | undefined;
+    siteUrl: string | undefined;
+} | {
+    url?: undefined;
+    siteUrl?: undefined;
+};

package/dist/runtime/nuxt/config.js

@@ -0,0 +1,12 @@
+import { useRuntimeConfig } from "#imports";
+export function getConvexRuntimeConfig() {
+  try {
+    const config = useRuntimeConfig();
+    return {
+      url: config.public?.convex?.url,
+      siteUrl: config.convex?.siteUrl || config.public?.convex?.siteUrl
+    };
+  } catch {
+    return {};
+  }
+}

package/dist/runtime/nuxt/index.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Helpers for integrating Convex into Nuxt applications using server rendering.
+ *
+ * This module contains:
+ * 1. {@link preloadQuery}, for preloading data for reactive client components.
+ * 2. {@link fetchQuery}, {@link fetchMutation} and {@link fetchAction} for loading and mutating Convex data
+ *   from Nuxt server routes, API handlers, and middleware.
+ *
+ * ## Usage
+ *
+ * All exported functions assume that a Convex deployment URL is set in the
+ * `NUXT_PUBLIC_CONVEX_URL` environment variable. `npx convex dev` will
+ * automatically set it during local development.
+ *
+ * ### Preloading data
+ *
+ * Preload data inside a server route:
+ *
+ * ```typescript
+ * // server/api/tasks.get.ts
+ * export default defineEventHandler(async () => {
+ *   return await preloadQuery(api.foo.baz)
+ * })
+ * ```
+ *
+ * And pass it to a client component:
+ * ```vue
+ * <script setup lang="ts">
+ * const props = defineProps<{
+ *   preloaded: Preloaded<typeof api.foo.baz>
+ * }>()
+ *
+ * const data = usePreloadedQuery(props.preloaded)
+ * // render `data`...
+ * </script>
+ * ```
+ *
+ * @module server
+ */
+import type { ArgsAndOptions, FunctionReference, FunctionReturnType } from 'convex/server';
+import type { Preloaded } from '../vue/index.js';
+/**
+ * Options to {@link preloadQuery}, {@link fetchQuery}, {@link fetchMutation} and {@link fetchAction}.
+ *
+ * @public
+ */
+export type NuxtOptions = {
+    /**
+     * The JWT-encoded OpenID Connect authentication token to use for the function call.
+     */
+    token?: string;
+    /**
+     * The URL of the Convex deployment to use for the function call.
+     * Defaults to `process.env.NUXT_PUBLIC_CONVEX_URL` if not provided.
+     *
+     * Explicitly passing undefined here (such as from missing ENV variables) will throw an error in the future.
+     */
+    url?: string;
+    /**
+     * @internal
+     */
+    adminToken?: string;
+    /**
+     * Skip validating that the Convex deployment URL looks like
+     * `https://happy-animal-123.convex.cloud` or localhost.
+     *
+     * This can be useful if running a self-hosted Convex deployment that uses a different
+     * URL.
+     *
+     * The default value is `false`
+     */
+    skipConvexDeploymentUrlCheck?: boolean;
+};
+/**
+ * Execute a Convex query function and return a `Preloaded`
+ * payload which can be passed to `usePreloadedQuery` in a client
+ * component.
+ *
+ * @param query - a `FunctionReference` for the public query to run
+ * like `api.dir1.dir2.filename.func`.
+ * @param args - The arguments object for the query. If this is omitted,
+ * the arguments will be `{}`.
+ * @param options -  A {@link NuxtOptions} options object for the query.
+ * @returns A promise of the `Preloaded` payload.
+ *
+ * @public
+ */
+export declare function preloadQuery<Query extends FunctionReference<'query'>>(query: Query, ...args: ArgsAndOptions<Query, NuxtOptions>): Promise<Preloaded<Query>>;
+/**
+ * Returns the result of executing a query via {@link preloadQuery}.
+ *
+ * @param preloaded - The `Preloaded` payload returned by {@link preloadQuery}.
+ * @returns The query result.
+ *
+ * @public
+ */
+export declare function preloadedQueryResult<Query extends FunctionReference<'query'>>(preloaded: Preloaded<Query>): FunctionReturnType<Query>;
+/**
+ * Execute a Convex query function.
+ *
+ * @param query - a `FunctionReference` for the public query to run
+ * like `api.dir1.dir2.filename.func`.
+ * @param args - The arguments object for the query. If this is omitted,
+ * the arguments will be `{}`.
+ * @param options -  A {@link NuxtOptions} options object for the query.
+ * @returns A promise of the query's result.
+ *
+ * @public
+ */
+export declare function fetchQuery<Query extends FunctionReference<'query'>>(query: Query, ...args: ArgsAndOptions<Query, NuxtOptions>): Promise<FunctionReturnType<Query>>;
+/**
+ * Execute a Convex mutation function.
+ *
+ * @param mutation - A `FunctionReference` for the public mutation
+ * to run like `api.dir1.dir2.filename.func`.
+ * @param args - The arguments object for the mutation. If this is omitted,
+ * the arguments will be `{}`.
+ * @param options -  A {@link NuxtOptions} options object for the mutation.
+ * @returns A promise of the mutation's result.
+ *
+ * @public
+ */
+export declare function fetchMutation<Mutation extends FunctionReference<'mutation'>>(mutation: Mutation, ...args: ArgsAndOptions<Mutation, NuxtOptions>): Promise<FunctionReturnType<Mutation>>;
+/**
+ * Execute a Convex action function.
+ *
+ * @param action - A `FunctionReference` for the public action
+ * to run like `api.dir1.dir2.filename.func`.
+ * @param args - The arguments object for the action. If this is omitted,
+ * the arguments will be `{}`.
+ * @param options -  A {@link NuxtOptions} options object for the action.
+ * @returns A promise of the action's result.
+ *
+ * @public
+ */
+export declare function fetchAction<Action extends FunctionReference<'action'>>(action: Action, ...args: ArgsAndOptions<Action, NuxtOptions>): Promise<FunctionReturnType<Action>>;

package/dist/runtime/nuxt/index.js

@@ -0,0 +1,91 @@
+import { ConvexHttpClient } from "convex/browser";
+import { getFunctionName } from "convex/server";
+import { convexToJson, jsonToConvex } from "convex/values";
+import { getConvexRuntimeConfig } from "./config.js";
+export async function preloadQuery(query, ...args) {
+  const value = await fetchQuery(query, ...args);
+  const preloaded = {
+    _name: getFunctionName(query),
+    _argsJSON: convexToJson(args[0] ?? {}),
+    _valueJSON: convexToJson(value)
+  };
+  return preloaded;
+}
+export function preloadedQueryResult(preloaded) {
+  return jsonToConvex(preloaded._valueJSON);
+}
+export async function fetchQuery(query, ...args) {
+  const [fnArgs, options] = args;
+  const client = setupClient(options ?? {});
+  return client.query(query, fnArgs || {});
+}
+export async function fetchMutation(mutation, ...args) {
+  const [fnArgs, options] = args;
+  const client = setupClient(options ?? {});
+  return client.mutation(mutation, fnArgs || {});
+}
+export async function fetchAction(action, ...args) {
+  const [fnArgs, options] = args;
+  const client = setupClient(options ?? {});
+  return client.action(action, fnArgs || {});
+}
+function setupClient(options) {
+  if ("url" in options && options.url === void 0) {
+    console.error(
+      "deploymentUrl is undefined, are your environment variables set? In the future explicitly passing undefined will cause an error. To explicitly use the default, pass `process.env.NUXT_PUBLIC_CONVEX_URL`."
+    );
+  }
+  const client = new ConvexHttpClient(
+    getConvexUrl(options.url, options.skipConvexDeploymentUrlCheck ?? false)
+  );
+  if (options.token !== void 0) {
+    client.setAuth(options.token);
+  }
+  if (options.adminToken !== void 0) {
+    client.setAdminAuth(options.adminToken);
+  }
+  client.setFetchOptions({ cache: "no-store" });
+  return client;
+}
+function getConvexUrl(deploymentUrl, skipConvexDeploymentUrlCheck) {
+  const url = deploymentUrl ?? (getConvexRuntimeConfig().url || void 0) ?? (process.env.NUXT_PUBLIC_CONVEX_URL || void 0);
+  const isFromEnv = deploymentUrl === void 0;
+  if (typeof url !== "string") {
+    throw new TypeError(
+      isFromEnv ? `Environment variable NUXT_PUBLIC_CONVEX_URL is not set.` : `Convex function called with invalid deployment address.`
+    );
+  }
+  if (!skipConvexDeploymentUrlCheck) {
+    validateDeploymentUrl(url);
+  }
+  return url;
+}
+function validateDeploymentUrl(deploymentUrl) {
+  if (typeof deploymentUrl === "undefined") {
+    throw new Error(
+      `Client created with undefined deployment address. If you used an environment variable, check that it's set.`
+    );
+  }
+  if (typeof deploymentUrl !== "string") {
+    throw new Error(
+      `Invalid deployment address: found ${deploymentUrl}".`
+    );
+  }
+  if (!(deploymentUrl.startsWith("http:") || deploymentUrl.startsWith("https:"))) {
+    throw new Error(
+      `Invalid deployment address: Must start with "https://" or "http://". Found "${deploymentUrl}".`
+    );
+  }
+  try {
+    new URL(deploymentUrl);
+  } catch {
+    throw new Error(
+      `Invalid deployment address: "${deploymentUrl}" is not a valid URL. If you believe this URL is correct, use the \`skipConvexDeploymentUrlCheck\` option to bypass this.`
+    );
+  }
+  if (deploymentUrl.endsWith(".convex.site")) {
+    throw new Error(
+      `Invalid deployment address: "${deploymentUrl}" ends with .convex.site, which is used for HTTP Actions. Convex deployment URLs typically end with .convex.cloud? If you believe this URL is correct, use the \`skipConvexDeploymentUrlCheck\` option to bypass this.`
+    );
+  }
+}

package/dist/runtime/polar/vue/components.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Vue ports of `@convex-dev/polar/react`'s billing components —
+ * {@link CheckoutLink} and {@link CustomerPortalLink}.
+ *
+ * @module polar/client
+ */
+import { type PropType } from 'vue';
+import type { FunctionReference } from 'convex/server';
+/**
+ * Args of the Polar-generated `generateCheckoutLink` action. Mirrors the
+ * argument shape `@convex-dev/polar`'s component exposes.
+ *
+ * @public
+ */
+export type CheckoutArgs = {
+    productIds: string[];
+    origin: string;
+    successUrl: string;
+    subscriptionId?: string;
+    metadata?: Record<string, string>;
+    /**
+     * `string | null` — not the literal-day/week/month/year union — because
+     * upstream's action arg is validator-derived (`v.union(v.string(), v.null())`),
+     * so the user's `_generated/api` reference types it that way; a narrower type
+     * here would reject their `:polar-api` binding. The component *prop* keeps
+     * the literal union, matching upstream's React prop declaration.
+     */
+    trialInterval?: string | null;
+    trialIntervalCount?: number | null;
+    locale?: string;
+};
+/**
+ * The subset of the Polar component's action references these components need —
+ * a Vue port mirror of `@convex-dev/polar`'s `PolarComponentApi`
+ * (`Pick<…, 'generateCheckoutLink' | 'generateCustomerPortalUrl'>`). Supplied
+ * via the auto-provided `api.billing` namespace, or passed through `:polar-api`.
+ *
+ * @public
+ */
+export interface PolarComponentApi {
+    generateCheckoutLink?: FunctionReference<'action', 'public', CheckoutArgs, {
+        url: string;
+    }>;
+    generateCustomerPortalUrl?: FunctionReference<'action', 'public', {
+        returnUrl?: string;
+    }, {
+        url: string;
+    }>;
+}
+/**
+ * @example
+ * ```vue
+ * <CustomerPortalLink>Manage subscription</CustomerPortalLink>
+ * ```
+ */
+export declare const CustomerPortalLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    polarApi: {
+        type: PropType<PolarComponentApi>;
+        default: undefined;
+    };
+    returnUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    polarApi: {
+        type: PropType<PolarComponentApi>;
+        default: undefined;
+    };
+    returnUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    returnUrl: string;
+    polarApi: PolarComponentApi;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * Renders a checkout link. Supports embedded or redirect checkout, with optional lazy loading and trial configuration.
+ *
+ * @example
+ * ```vue
+ * <CheckoutLink :product-ids="[productId]" :trial-interval-count="7" trial-interval="day">
+ *   Start free trial
+ * </CheckoutLink>
+ * ```
+ */
+export declare const CheckoutLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    polarApi: {
+        type: PropType<PolarComponentApi>;
+        default: undefined;
+    };
+    productIds: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    subscriptionId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    metadata: {
+        type: PropType<Record<string, string>>;
+        default: undefined;
+    };
+    trialInterval: {
+        type: PropType<"day" | "week" | "month" | "year" | null>;
+        default: undefined;
+    };
+    trialIntervalCount: {
+        type: PropType<number | null>;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    theme: {
+        type: PropType<"dark" | "light">;
+        default: string;
+    };
+    embed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    lazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    polarApi: {
+        type: PropType<PolarComponentApi>;
+        default: undefined;
+    };
+    productIds: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    subscriptionId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    metadata: {
+        type: PropType<Record<string, string>>;
+        default: undefined;
+    };
+    trialInterval: {
+        type: PropType<"day" | "week" | "month" | "year" | null>;
+        default: undefined;
+    };
+    trialIntervalCount: {
+        type: PropType<number | null>;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    theme: {
+        type: PropType<"dark" | "light">;
+        default: string;
+    };
+    embed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    lazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    lazy: boolean;
+    metadata: Record<string, string>;
+    embed: boolean;
+    subscriptionId: string;
+    trialInterval: "day" | "week" | "month" | "year" | null;
+    trialIntervalCount: number | null;
+    locale: string;
+    polarApi: PolarComponentApi;
+    theme: "dark" | "light";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;