@dyrected/vue 0.0.0-pr-18-20260828214838

package/LICENSE.md

@@ -0,0 +1,50 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor: Dyrected
+Licensed Work: Dyrected
+Additional Use Grant: Production use and commercial use of the Licensed Work are permitted for your own internal business operations, your own websites and applications, and client websites or applications that you build or deploy on behalf of a client, provided that you do not, without a separate commercial license from the Licensor, (a) provide the Licensed Work as a hosted or managed service to third parties, (b) embed, white-label, sublicense, or otherwise redistribute the Licensed Work as part of a multi-tenant or customer-facing SaaS, platform, or developer service, or (c) enable third parties to create, manage, or operate independent projects, sites, workspaces, or environments using the Licensed Work as a material part of the service you provide.
+Change Date: 2030-05-18
+Change License: Apache License 2.0
+
+---
+
+Business Source License 1.1
+
+License text copyright © 2024 MariaDB plc, All Rights Reserved.
+“Business Source License” is a trademark of MariaDB plc.
+
+### Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative works, redistribute, and make non-production use of the Licensed Work. The Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly available distribution of a specific version of the Licensed Work under this License, whichever comes first, the Licensor hereby grants you rights under the terms of the Change License, and the rights granted in the paragraph above terminate.
+
+If your use of the Licensed Work does not comply with the requirements currently in effect as described in this License, you must purchase a commercial license from the Licensor, its affiliated entities, or authorized resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works of the Licensed Work, are subject to this License. This License applies separately for each version of the Licensed Work and the Change Date may vary for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy of the Licensed Work. If you receive the Licensed Work in original or modified form from a third party, the terms and conditions set forth in this License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically terminate your rights under this License for the current and all other versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of Licensor or its affiliates (provided that you may use a trademark or logo of Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND TITLE.
+
+MariaDB hereby grants you permission to use this License’s text to license your works, and to refer to it using the trademark “Business Source License”, as long as you comply with the Covenants of Licensor below.
+
+### Covenants of Licensor
+
+In consideration of the right to use this License’s text and the “Business Source License” name and trademark, Licensor covenants to MariaDB, and to all other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version, or a license that is compatible with GPL Version 2.0 or a later version, where “compatible” means that software provided under the Change License can be included in a program with software provided under GPL Version 2.0 or a later version. Licensor may specify additional Change Licenses without limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not impose any additional restriction on the right granted in this License, as the Additional Use Grant; or (b) insert the text “None”.
+
+3. Not to modify this License in any other way.
+
+---
+
+The Business Source License (this document, or the “License”) is not an Open Source license. However, the Licensed Work will eventually be made available under an Open Source License, as stated in this License.

package/dist/bridge/react-in-vue.d.ts

@@ -0,0 +1,31 @@
+import { AppContext, Component } from 'vue';
+import * as ReactModule from 'react';
+/**
+ * wrapVueComponent — Higher-order component that wraps a Vue 3 component
+ * so it can be rendered within a React component tree.
+ *
+ * Rather than spinning up a full `createApp()` per rendered instance, each
+ * island is mounted with Vue's low-level `render()` and shares a single
+ * `appContext` — normally the host app's, captured by `<DyrectedAdmin>`. That
+ * keeps the cost of many custom fields/slots low and lets host-app plugins,
+ * `provide`/`inject`, Pinia, and i18n flow into custom components.
+ *
+ * React is imported from the host dependency graph. The Nuxt adapter dedupes
+ * React resolution so custom Vue field components share the admin's React copy.
+ */
+export declare function wrapVueComponent(VueComp: Component, appContext?: AppContext | null): {
+    (props: any): ReactModule.DetailedReactHTMLElement<{
+        ref: ReactModule.RefObject<HTMLDivElement | null>;
+        className: string;
+        style: {
+            display: "contents";
+        };
+    }, HTMLDivElement>;
+    displayName: string;
+};
+/**
+ * wrapComponents — Recursively wraps all components in a nested object.
+ * Useful for the `components` prop in DyrectedAdmin. The optional `appContext`
+ * is threaded down so every wrapped island shares the host app's context.
+ */
+export declare function wrapComponents(components: any, appContext?: AppContext | null): any;

package/dist/components/Blocks.d.ts

@@ -0,0 +1,57 @@
+import { PropType, Component } from 'vue';
+export interface BlocksItem {
+    /** Discriminator selecting which component renders this item. */
+    blockType: string;
+    /**
+     * Selected presentation variant, when the block defines `variants` in its
+     * schema. Passed straight through to the component so it can switch layout.
+     */
+    variant?: string;
+    /** Optional stable id; used as the render key when present. */
+    id?: string;
+    [key: string]: unknown;
+}
+/**
+ * Blocks — renders an array of block items by `blockType`, wrapping each in a
+ * `DyPathScope` scoped to `${path}.${index}` so child components can call
+ * `useDyPath('field')` without ever writing an index or full path.
+ *
+ * Render-function component (no template/JSX) so the package needs no extra
+ * build tooling.
+ *
+ * @example (render function usage in a page)
+ *   h(Blocks, { items: data.body, components: { hero: HeroBlock } })
+ * @example (template usage)
+ *   <Blocks :items="data.body" :components="{ hero: HeroBlock }" />
+ */
+export declare const Blocks: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    items: {
+        type: PropType<BlocksItem[]>;
+        required: true;
+    };
+    components: {
+        type: PropType<Record<string, Component>>;
+        required: true;
+    };
+    path: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => (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<{
+    items: {
+        type: PropType<BlocksItem[]>;
+        required: true;
+    };
+    components: {
+        type: PropType<Record<string, Component>>;
+        required: true;
+    };
+    path: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    path: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/DyPathScope.d.ts

@@ -0,0 +1,25 @@
+/**
+ * DyPathScope — a minimal wrapper component whose sole job is to own one
+ * `provide()` scope for the ambient base path.
+ *
+ * In Vue, `provide()` is bound to the calling component *instance*, not to a
+ * render position, so a single component cannot provide a distinct value per
+ * item in a loop. `<Blocks>` renders one `DyPathScope` per item to give each
+ * block its own scoped base path.
+ *
+ * Written as a render-function component (no template/JSX) so the package needs
+ * no extra build tooling.
+ */
+export declare const DyPathScope: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/DyrectedAdmin.vue.d.ts

@@ -0,0 +1,27 @@
+import { AdminThemeController, AdminThemePreference, ResolvedAdminTheme } from '@dyrected/admin/public';
+type __VLS_Props = {
+    /**
+     * The Dyrected configuration object.
+     */
+    config: {
+        apiKey: string;
+        siteId: string;
+        baseUrl: string;
+    };
+    /**
+     * Custom components to inject into the Admin UI.
+     * Can be raw Vue components; they will be automatically wrapped.
+     */
+    components?: any;
+    /** Optional externally managed admin theme controller. */
+    themeController?: AdminThemeController;
+    /** Preferred theme when the wrapper should control the admin theme. */
+    theme?: AdminThemePreference;
+    /** Current resolved system theme when the wrapper should control the admin theme. */
+    systemTheme?: ResolvedAdminTheme;
+    /** Called when the admin UI changes the preferred theme. */
+    onThemeChange?: (theme: AdminThemePreference) => void;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/DyrectedIcon.vue.d.ts

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    /**
+     * The value of an `icon` field — a Lucide icon name such as
+     * `"ChartNoAxesCombined"` or `"BellRing"`. See https://lucide.dev/icons.
+     * Typed as `string` rather than the 1700+ icon-name union to avoid a TS
+     * "union too complex" (TS2590) blow-up in the generated declarations.
+     */
+    name?: string | null;
+    /**
+     * Icon name to render when `name` is missing or not a known icon.
+     * Renders nothing when omitted and `name` cannot be resolved.
+     */
+    fallback?: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/DyrectedImage.vue.d.ts

@@ -0,0 +1,10 @@
+import { Media } from '@dyrected/sdk';
+type __VLS_Props = {
+    media: Media | string;
+    width?: number | string;
+    height?: number | string;
+    alt?: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/DyrectedMedia.vue.d.ts

@@ -0,0 +1,20 @@
+import { Media } from '@dyrected/sdk';
+type __VLS_Props = {
+    media: Media | string;
+    width?: number | string;
+    height?: number | string;
+    alt?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    fallback?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DyrectedRichText.vue.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Renders a Dyrected `richText` field value.
+ *
+ * The field stores an HTML string, so this outputs it via `v-html`. Render only
+ * content you trust; sanitize upstream if untrusted users can author it.
+ */
+type __VLS_Props = {
+    content?: string | null;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/composables/useAddMediaFromUrl.d.ts

@@ -0,0 +1,9 @@
+import { UseMediaURLOptions } from './useMediaURL';
+export interface UseAddMediaFromUrlOptions extends UseMediaURLOptions {
+}
+/**
+ * Backwards-compatible alias for `useMediaURL`.
+ *
+ * Prefer `useMediaURL` for new code.
+ */
+export declare function useAddMediaFromUrl(options: UseAddMediaFromUrlOptions): import('./useAdminSchemas').VueStateify<import('@dyrected/admin/public').MediaURLHookResult>;

package/dist/composables/useAdminSchemas.d.ts

@@ -0,0 +1,12 @@
+import { AdminSchemasResult } from '@dyrected/admin/public';
+export type VueStateify<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? T[K] : Readonly<import('vue').Ref<T[K]>>;
+};
+/**
+ * Loads the admin schema registry for the current Dyrected client.
+ *
+ * Most apps will use higher-level composables like `useMediaUpload` instead of
+ * calling this directly. It exists as the schema-aware foundation for custom
+ * Vue admin UI.
+ */
+export declare function useAdminSchemas(): VueStateify<AdminSchemasResult>;

package/dist/composables/useAdminTheme.d.ts

@@ -0,0 +1,22 @@
+import { InjectionKey } from 'vue';
+import { AdminThemeHookResult, AdminThemeController, AdminThemeControllerOptions } from '@dyrected/admin/public';
+import { VueStateify } from './useAdminSchemas';
+export interface ProvideAdminThemeOptions extends AdminThemeControllerOptions {
+    /** Use an existing theme controller instead of creating one. */
+    controller?: AdminThemeController;
+}
+export declare const ADMIN_THEME_CONTROLLER_KEY: InjectionKey<AdminThemeController>;
+/**
+ * Creates or provides an admin theme controller to the current Vue subtree.
+ *
+ * This is the recommended entry point when you want theme state to be shared by
+ * a custom Vue admin surface.
+ */
+export declare function provideAdminTheme(options?: ProvideAdminThemeOptions): AdminThemeController;
+/**
+ * Vue composable for reading and mutating Dyrected admin theme state.
+ *
+ * When no provider is present, it falls back to a local system-theme-derived
+ * read-only state so components can still render consistently.
+ */
+export declare function useAdminTheme(): VueStateify<AdminThemeHookResult>;

package/dist/composables/useDyPath.d.ts

@@ -0,0 +1,30 @@
+import { InjectionKey } from 'vue';
+/**
+ * Injection key carrying the ambient base path for the block/section currently
+ * being rendered, e.g. "body.2". `provideDyPath` sets it; `useDyPath` reads it.
+ * Defaults to '' (document root).
+ */
+export declare const DY_PATH_KEY: InjectionKey<string>;
+/**
+ * provideDyPath — set the ambient base path for the current component's
+ * subtree. Must be called in `setup()`. `<Blocks>` calls this for you via
+ * `DyPathScope`; use it directly only for a standalone section.
+ */
+export declare function provideDyPath(path: string): void;
+/**
+ * useDyPath — returns an attribute object annotating an element with its
+ * document value path, so the Dyrected live-preview editor can map a click in
+ * the preview back to the exact field. Spread it onto the element (render
+ * functions) or bind with `v-bind` in templates.
+ *
+ * Must be called in `setup()`. Authors pass only the field name relative to the
+ * current block; the ancestor `<Blocks>`/`provideDyPath` supplies the base path.
+ *
+ * @example (render function)
+ *   h('h1', useDyPath('heading'), props.heading)
+ * @example (template)
+ *   <h1 v-bind="useDyPath('heading')">{{ heading }}</h1>
+ */
+export declare function useDyPath(field?: string): {
+    'data-dy-path': string;
+};

package/dist/composables/useDyrected.d.ts

@@ -0,0 +1,53 @@
+import { Ref, InjectionKey } from 'vue';
+import { DyrectedClient, SchemaShape, RegisteredSchema } from '@dyrected/sdk';
+/** A collection slug from your registered schema (or any string until types are generated). */
+type CollectionSlug = keyof RegisteredSchema['collections'] & string;
+/** The document type for a given collection slug. */
+type CollectionDoc<K extends CollectionSlug> = RegisteredSchema['collections'][K];
+/** A global slug from your registered schema. */
+type GlobalSlug = keyof RegisteredSchema['globals'] & string;
+/** The data type for a given global slug. */
+type GlobalData<K extends GlobalSlug> = RegisteredSchema['globals'][K];
+export declare const DYRECTED_CLIENT_KEY: InjectionKey<DyrectedClient>;
+/**
+ * useDyrectedClient — Returns the injected Dyrected client.
+ */
+export declare function useDyrectedClient<TSchema extends SchemaShape = RegisteredSchema>(): DyrectedClient<TSchema>;
+/**
+ * provideDyrectedClient — Provides a Dyrected client to the Vue app.
+ */
+export declare function provideDyrectedClient(client: DyrectedClient): {
+    [x: number]: DyrectedClient<import('@dyrected/sdk').BaseSchema>;
+};
+export interface UseDyrectedOptions {
+    depth?: number;
+    [key: string]: any;
+}
+/**
+ * useDyrected — Reactive composable for fetching a single document.
+ */
+export declare function useDyrected<K extends CollectionSlug, T = CollectionDoc<K>>(collection: K, idOrSlug: string, options?: UseDyrectedOptions): {
+    doc: Ref<T | null, T | null>;
+    pending: Ref<boolean, boolean>;
+    error: Ref<any, any>;
+    refresh: () => Promise<void>;
+};
+/**
+ * useDyrectedCollection — Reactive composable for fetching a collection.
+ */
+export declare function useDyrectedCollection<K extends CollectionSlug, T = CollectionDoc<K>>(collection: K, options?: UseDyrectedOptions): {
+    docs: Ref<T[], T[]>;
+    pending: Ref<boolean, boolean>;
+    error: Ref<any, any>;
+    refresh: () => Promise<void>;
+};
+/**
+ * useDyrectedGlobal — Reactive composable for fetching a global.
+ */
+export declare function useDyrectedGlobal<K extends GlobalSlug, T = GlobalData<K>>(slug: K, options?: UseDyrectedOptions): {
+    data: Ref<T | null, T | null>;
+    pending: Ref<boolean, boolean>;
+    error: Ref<any, any>;
+    refresh: () => Promise<void>;
+};
+export {};

package/dist/composables/useDyrectedAuth.d.ts

@@ -0,0 +1,32 @@
+import { Ref } from 'vue';
+import { DyrectedClient } from '@dyrected/sdk';
+export interface DyrectedAuthUser {
+    id: string;
+    email: string;
+    [key: string]: any;
+}
+export interface UseDyrectedAuthOptions {
+    baseUrl: string;
+    apiKey: string;
+    siteId?: string;
+    /**
+     * Optional token storage. Defaults to localStorage.
+     */
+    storage?: {
+        getItem: (key: string) => string | null;
+        setItem: (key: string, value: string) => void;
+        removeItem: (key: string) => void;
+    };
+}
+/**
+ * useDyrectedAuth — Generic Vue composable for auth collections.
+ */
+export declare function useDyrectedAuth(collection: string, options: UseDyrectedAuthOptions): {
+    user: Ref<DyrectedAuthUser | null, DyrectedAuthUser | null>;
+    isLoggedIn: import('vue').ComputedRef<boolean>;
+    token: Ref<string | null, string | null>;
+    login: (email: string, password: string) => Promise<DyrectedAuthUser>;
+    logout: () => Promise<void>;
+    fetchMe: () => Promise<DyrectedAuthUser | null>;
+    client: DyrectedClient<import('@dyrected/sdk').BaseSchema>;
+};

package/dist/composables/useDyrectedForm.d.ts

@@ -0,0 +1,34 @@
+import { InjectionKey } from 'vue';
+import { DyrectedFormController, DyrectedFormHookResult } from '@dyrected/admin/public';
+import { VueStateify } from './useAdminSchemas';
+export declare const DYRECTED_FORM_CONTROLLER_KEY: InjectionKey<DyrectedFormController>;
+export declare const DYRECTED_FIELD_PATH_KEY: InjectionKey<string | null>;
+/**
+ * Provides a Dyrected form controller to the current Vue component subtree.
+ *
+ * Call this once near the root of a custom form implementation, then use
+ * `useDyrectedForm()` and `useField()` lower in the tree.
+ */
+export declare function provideDyrectedForm(controller: DyrectedFormController): DyrectedFormController;
+/**
+ * Provides the ambient field path for descendant `useField()` calls.
+ *
+ * This is useful when building nested field components that should resolve
+ * child paths relative to a parent object, array item, or block.
+ */
+export declare function provideDyrectedFieldPath(path: string): void;
+/**
+ * Returns the current Dyrected form controller from Vue injection context.
+ */
+export declare function useDyrectedFormController(): DyrectedFormController;
+/**
+ * Returns the current ambient field path from Vue injection context.
+ */
+export declare function useDyrectedFieldPath(): string | null;
+/**
+ * Vue composable for reading and mutating Dyrected form state.
+ *
+ * Use this inside custom form shells, field containers, or document editors
+ * that are backed by a provided `DyrectedFormController`.
+ */
+export declare function useDyrectedForm(): VueStateify<DyrectedFormHookResult>;

package/dist/composables/useField.d.ts

@@ -0,0 +1,9 @@
+import { DyrectedFieldHookResult } from '@dyrected/admin/public';
+import { VueStateify } from './useAdminSchemas';
+/**
+ * Vue composable for interacting with a single Dyrected field.
+ *
+ * Pass a full field path directly, or rely on `provideDyrectedFieldPath()` to
+ * resolve paths relative to the current nested field scope.
+ */
+export declare function useField(path?: string): VueStateify<DyrectedFieldHookResult>;

package/dist/composables/useLivePreview.d.ts

@@ -0,0 +1,24 @@
+import { Ref } from 'vue';
+export interface LivePreviewOptions<T> {
+    /**
+     * The initial data to show before any postMessage arrives.
+     */
+    initialData: T;
+    /**
+     * The origin of the Dyrected Admin UI that will send preview messages.
+     * Defaults to '*' (accepts from any origin).
+     */
+    serverURL?: string;
+}
+/**
+ * useLivePreview — Vue composable for Dyrected live preview (postMessage mode).
+ *
+ * Listen for postMessage events from the Admin UI and update data reactively.
+ * Supports inline edit mode: when the Admin sends 'dyrected-enter-edit-mode',
+ * elements with data-dy-path become clickable so the Admin sidebar scrolls to
+ * the matching field.
+ */
+export declare function useLivePreview<T = any>(options: LivePreviewOptions<T>): {
+    data: Ref<T>;
+    isLive: Ref<boolean>;
+};

package/dist/composables/useMediaLibrary.d.ts

@@ -0,0 +1,10 @@
+import { MediaLibraryHookOptions, MediaLibraryHookResult } from '@dyrected/admin/public';
+import { VueStateify } from './useAdminSchemas';
+export type UseMediaLibraryOptions = MediaLibraryHookOptions;
+/**
+ * Vue composable for browsing and selecting media from the Dyrected media library.
+ *
+ * It exposes reactive pagination, search, selection, and loading state so host
+ * apps can build their own picker UI without reimplementing library behavior.
+ */
+export declare function useMediaLibrary({ collection, pageSize, initialSearchQuery, initialSelectedIds, }: UseMediaLibraryOptions): VueStateify<MediaLibraryHookResult>;

package/dist/composables/useMediaURL.d.ts

@@ -0,0 +1,10 @@
+import { MediaURLHookOptions, MediaURLHookResult } from '@dyrected/admin/public';
+import { VueStateify } from './useAdminSchemas';
+export type UseMediaURLOptions = MediaURLHookOptions;
+/**
+ * Vue composable for Dyrected's URL-based media ingestion flow.
+ *
+ * It classifies external URLs and routes them through the same shared media
+ * ingestion behavior used by the admin app.
+ */
+export declare function useMediaURL({ collection, compressImages, maxDimension, quality, onAdded, onError, }: UseMediaURLOptions): VueStateify<MediaURLHookResult>;

package/dist/composables/useMediaUpload.d.ts

@@ -0,0 +1,10 @@
+import { MediaUploadHookOptions, MediaUploadHookResult } from '@dyrected/admin/public';
+import { VueStateify } from './useAdminSchemas';
+export type UseMediaUploadOptions = MediaUploadHookOptions;
+/**
+ * Vue composable for Dyrected's shared media upload pipeline.
+ *
+ * Use this to build a custom upload UI while reusing the admin app's queueing,
+ * image compression, progress tracking, and collection resolution behavior.
+ */
+export declare function useMediaUpload({ collectionSlug, compressImages, maxDimension, quality, onCompletedItem, onAllCompleted, onError, }?: UseMediaUploadOptions): VueStateify<MediaUploadHookResult>;