@codingfactory/mediables-vue 2.0.1

package/dist/composables/useLiveStream.d.ts

@@ -0,0 +1,66 @@
+import type { LiveStream, LiveStreamOptions } from '../types/video';
+interface HttpClient {
+    <T = unknown>(url: string, options?: {
+        method?: string;
+        body?: string;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+}
+export declare function configureHttpClient(client: HttpClient): void;
+export declare function useLiveStream(mediaUuid?: string): {
+    stream: import("vue").Ref<{
+        id: string;
+        media_uuid: string;
+        stream_key: string;
+        rtmp_url: string;
+        playback_url?: string | undefined;
+        status: "idle" | "starting" | "live" | "stopping" | "ended" | "error";
+        started_at?: string | undefined;
+        ended_at?: string | undefined;
+        viewer_count: number;
+        peak_viewers: number;
+        auto_record: boolean;
+        low_latency: boolean;
+        vod_media_uuid?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    } | null, LiveStream | {
+        id: string;
+        media_uuid: string;
+        stream_key: string;
+        rtmp_url: string;
+        playback_url?: string | undefined;
+        status: "idle" | "starting" | "live" | "stopping" | "ended" | "error";
+        started_at?: string | undefined;
+        ended_at?: string | undefined;
+        viewer_count: number;
+        peak_viewers: number;
+        auto_record: boolean;
+        low_latency: boolean;
+        vod_media_uuid?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    } | null>;
+    lowLatency: import("vue").Ref<boolean, boolean>;
+    autoRecord: import("vue").Ref<boolean, boolean>;
+    streamTitle: import("vue").Ref<string, string>;
+    isCreating: import("vue").Ref<boolean, boolean>;
+    isEnding: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<string | null, string | null>;
+    streamDuration: import("vue").ComputedRef<number>;
+    viewerCount: import("vue").Ref<number, number>;
+    peakViewers: import("vue").Ref<number, number>;
+    playbackUrl: import("vue").ComputedRef<string | null>;
+    isLive: import("vue").ComputedRef<boolean>;
+    isIdle: import("vue").ComputedRef<boolean>;
+    hasEnded: import("vue").ComputedRef<boolean>;
+    createStream: (options?: LiveStreamOptions) => Promise<LiveStream>;
+    endStream: () => Promise<LiveStream>;
+    refreshStreamStatus: () => Promise<void>;
+    getStreamCredentials: (streamId: string) => Promise<{
+        rtmp_url: string;
+        stream_key: string;
+        playback_url: string;
+    }>;
+    startStatusPolling: (interval?: number) => void;
+    stopStatusPolling: () => void;
+};
+export {};

package/dist/composables/useMediaAttachment.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Media Attachment Composable
+ * Simplified composable for single-file attachments
+ * Wraps useMediaCollection with maxItems: 1
+ */
+import { type Ref, type ComputedRef } from 'vue';
+import type { Media } from '../types/media';
+import type { MediaItem, UploadProgress, ValidationRules, ValidationError } from '../types/collection';
+import type { StorageAdapter } from '../types/adapter';
+/**
+ * Options for useMediaAttachment
+ * Note: Omits onChange since it has a different signature (single item vs array)
+ */
+export interface UseMediaAttachmentOptions {
+    /** Initial item */
+    initialItem?: MediaItem | Media | null | undefined;
+    /** Model type for API operations */
+    modelType?: string | undefined;
+    /** Model ID for API operations */
+    modelId?: string | number | undefined;
+    /** Collection name */
+    collection?: string | undefined;
+    /** Maximum file size in bytes */
+    maxFileSize?: number | undefined;
+    /** Accepted MIME types */
+    acceptedMimeTypes?: string[] | undefined;
+    /** Whether the attachment is disabled */
+    disabled?: boolean | undefined;
+    /** Validation rules */
+    rules?: ValidationRules | undefined;
+    /** Storage adapter type */
+    adapterType?: 'mediables' | 'spatie' | undefined;
+    /** Custom storage adapter */
+    adapter?: StorageAdapter | undefined;
+    /** Maximum concurrent uploads */
+    maxConcurrentUploads?: number | undefined;
+    /** Callback when item changes */
+    onChange?: ((item: MediaItem | null) => void) | undefined;
+    /** Callback on upload */
+    onUpload?: ((progress: UploadProgress) => void) | undefined;
+    /** Callback when upload completes */
+    onUploadComplete?: ((media: Media) => void) | undefined;
+    /** Callback on upload error */
+    onUploadError?: ((error: {
+        file: File;
+        message: string;
+    }) => void) | undefined;
+    /** Callback when item is removed */
+    onRemove?: ((item: MediaItem) => void) | undefined;
+    /** Callback when item is replaced */
+    onReplace?: ((oldItem: MediaItem | null, newItem: MediaItem) => void) | undefined;
+    /** Callback on validation errors */
+    onError?: ((errors: ValidationError[]) => void) | undefined;
+    /** Callback when ready-to-submit state changes */
+    onReadyToSubmitChange?: ((ready: boolean) => void) | undefined;
+}
+/**
+ * Return type for useMediaAttachment
+ */
+export interface UseMediaAttachmentReturn {
+    /** Current item */
+    item: ComputedRef<MediaItem | null>;
+    /** Set item directly */
+    setItem: (item: MediaItem | Media | null) => void;
+    /** Add file (replaces current) */
+    addFile: (file: File) => Promise<void>;
+    /** Remove current item */
+    removeItem: () => void;
+    /** Replace current item with new file */
+    replaceItem: (file: File) => Promise<void>;
+    /** Cancel current upload */
+    cancelUpload: () => void;
+    /** Retry failed upload */
+    retryUpload: () => Promise<void>;
+    /** Save to server */
+    save: () => Promise<void>;
+    /** Load from server */
+    load: () => Promise<void>;
+    /** Whether loading */
+    isLoading: Ref<boolean>;
+    /** Whether uploading */
+    isUploading: ComputedRef<boolean>;
+    /** Whether ready to submit */
+    isReadyToSubmit: ComputedRef<boolean>;
+    /** Whether has an item */
+    hasItem: ComputedRef<boolean>;
+    /** Current errors */
+    errors: Ref<ValidationError[]>;
+    /** Storage adapter */
+    adapter: StorageAdapter;
+    /** Form value (for hidden field) */
+    formValue: ComputedRef<{
+        uuid: string;
+        name: string;
+        order: number;
+        custom_properties?: Record<string, unknown> | undefined;
+    } | null>;
+    /** Accept string for file input */
+    acceptString: Ref<string>;
+}
+/**
+ * Composable for single-file attachments
+ */
+export declare function useMediaAttachment(options?: UseMediaAttachmentOptions): UseMediaAttachmentReturn;
+export default useMediaAttachment;

package/dist/composables/useMediaCollection.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Media Collection Composable
+ * Main composable for managing a collection of media items
+ * Provides state management, uploads, validation, and sorting
+ */
+import { type Ref, type ComputedRef } from 'vue';
+import type { Media } from '../types/media';
+import type { MediaItem, UploadProgress, ValidationRules, ValidationError, MediaCollectionLabels } from '../types/collection';
+import type { StorageAdapter } from '../types/adapter';
+/**
+ * Options for useMediaCollection
+ */
+export interface UseMediaCollectionOptions {
+    /** Initial items */
+    initialItems?: MediaItem[] | Media[] | undefined;
+    /** Model type for API operations */
+    modelType?: string | undefined;
+    /** Model ID for API operations */
+    modelId?: string | number | undefined;
+    /** Collection name */
+    collection?: string | undefined;
+    /** Maximum number of items */
+    maxItems?: number | undefined;
+    /** Maximum file size in bytes */
+    maxFileSize?: number | undefined;
+    /** Accepted MIME types */
+    acceptedMimeTypes?: string[] | undefined;
+    /** Whether items can be sorted */
+    sortable?: boolean | undefined;
+    /** Whether the collection is disabled */
+    disabled?: boolean | undefined;
+    /** Validation rules */
+    rules?: ValidationRules | undefined;
+    /** Storage adapter type */
+    adapterType?: 'mediables' | 'spatie' | undefined;
+    /** Custom storage adapter */
+    adapter?: StorageAdapter | undefined;
+    /** Maximum concurrent uploads */
+    maxConcurrentUploads?: number | undefined;
+    /** Custom labels */
+    labels?: Partial<MediaCollectionLabels> | undefined;
+    /** Callbacks */
+    onChange?: ((items: MediaItem[]) => void) | undefined;
+    onUpload?: ((progress: UploadProgress) => void) | undefined;
+    onUploadComplete?: ((media: Media) => void) | undefined;
+    onUploadError?: ((error: {
+        file: File;
+        message: string;
+    }) => void) | undefined;
+    onRemove?: ((item: MediaItem) => void) | undefined;
+    onReorder?: ((items: MediaItem[]) => void) | undefined;
+    onError?: ((errors: ValidationError[]) => void) | undefined;
+    onReadyToSubmitChange?: ((ready: boolean) => void) | undefined;
+}
+/**
+ * Return type for useMediaCollection
+ */
+export interface UseMediaCollectionReturn {
+    /** Current items */
+    items: Ref<MediaItem[]>;
+    /** Set items directly */
+    setItems: (items: MediaItem[] | Media[]) => void;
+    /** Add files to upload */
+    addFiles: (files: FileList | File[]) => Promise<void>;
+    /** Remove an item */
+    removeItem: (item: MediaItem) => void;
+    /** Remove item by client ID */
+    removeItemById: (clientId: string) => void;
+    /** Clear all items */
+    clearAll: () => void;
+    /** Reorder items */
+    reorderItems: (fromIndex: number, toIndex: number) => void;
+    /** Update item metadata */
+    updateItem: (clientId: string, updates: Partial<MediaItem>) => void;
+    /** Cancel an upload */
+    cancelUpload: (uploadId: string) => void;
+    /** Retry a failed upload */
+    retryUpload: (uploadId: string) => Promise<void>;
+    /** Save to server (attach to model) */
+    save: () => Promise<void>;
+    /** Load from server */
+    load: () => Promise<void>;
+    /** Whether collection is loading */
+    isLoading: Ref<boolean>;
+    /** Whether there are active uploads */
+    isUploading: ComputedRef<boolean>;
+    /** Whether ready to submit */
+    isReadyToSubmit: ComputedRef<boolean>;
+    /** Whether at max items */
+    isAtMaxItems: ComputedRef<boolean>;
+    /** Current errors */
+    errors: Ref<ValidationError[]>;
+    /** Drag state (for sortable) */
+    dragState: Ref<{
+        isDragging: boolean;
+        dragIndex: number | null;
+        dropIndex: number | null;
+        draggedItem: MediaItem | null;
+    }>;
+    /** Get drag props for an item */
+    getDragProps: (item: MediaItem, index: number) => Record<string, unknown>;
+    /** Storage adapter */
+    adapter: StorageAdapter;
+    /** Form values (for hidden fields) */
+    formValues: ComputedRef<Array<{
+        uuid: string;
+        name: string;
+        order: number;
+        custom_properties?: Record<string, unknown> | undefined;
+    }>>;
+    /** Accept string for file input */
+    acceptString: Ref<string>;
+    /** Items count */
+    count: ComputedRef<number>;
+    /** Remaining slots available */
+    remainingSlots: ComputedRef<number>;
+}
+/**
+ * Composable for managing media collections
+ */
+export declare function useMediaCollection(options?: UseMediaCollectionOptions): UseMediaCollectionReturn;
+export default useMediaCollection;

package/dist/composables/useMediaConversionProgress.d.ts

@@ -0,0 +1,31 @@
+export interface ConversionProgress {
+    uuid: string;
+    status: 'processing' | 'completed' | 'failed';
+    progress: number;
+    message?: string;
+    conversions?: {
+        [key: string]: boolean;
+    };
+}
+export declare function useMediaConversionProgress(): {
+    progressMap: import("vue").Ref<Map<string, {
+        uuid: string;
+        status: "processing" | "completed" | "failed";
+        progress: number;
+        message?: string | undefined;
+        conversions?: {
+            [key: string]: boolean;
+        } | undefined;
+    }> & Omit<Map<string, ConversionProgress>, keyof Map<any, any>>, Map<string, ConversionProgress> | (Map<string, {
+        uuid: string;
+        status: "processing" | "completed" | "failed";
+        progress: number;
+        message?: string | undefined;
+        conversions?: {
+            [key: string]: boolean;
+        } | undefined;
+    }> & Omit<Map<string, ConversionProgress>, keyof Map<any, any>>)>;
+    trackProgress: (mediaUuid: string) => Promise<ConversionProgress | null>;
+    clearProgress: (mediaUuid: string) => void;
+    clearAllProgress: () => void;
+};

package/dist/composables/useMediaDragSort.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Media Drag Sort Composable
+ * Provides drag-and-drop reordering functionality for media items
+ */
+import { type Ref } from 'vue';
+import type { MediaItem, DragState, DragEvent as MediaDragEvent } from '../types/collection';
+/**
+ * Options for useMediaDragSort
+ */
+export interface UseMediaDragSortOptions {
+    /** Whether sorting is enabled */
+    enabled?: boolean;
+    /** Callback when items are reordered */
+    onReorder?: (event: MediaDragEvent) => void;
+    /** Callback when drag starts */
+    onDragStart?: (item: MediaItem, index: number) => void;
+    /** Callback when drag ends */
+    onDragEnd?: () => void;
+    /** CSS class to add to dragging element */
+    draggingClass?: string;
+    /** CSS class to add to drop target */
+    dropTargetClass?: string;
+}
+/**
+ * Return type for useMediaDragSort
+ */
+export interface UseMediaDragSortReturn {
+    /** Current drag state */
+    dragState: Ref<DragState>;
+    /** Whether currently dragging */
+    isDragging: Ref<boolean>;
+    /** Start dragging an item */
+    startDrag: (event: globalThis.DragEvent | MouseEvent | TouchEvent, item: MediaItem, index: number) => void;
+    /** Handle drag over event */
+    handleDragOver: (event: globalThis.DragEvent | MouseEvent | TouchEvent, index: number) => void;
+    /** End drag operation */
+    endDrag: () => void;
+    /** Cancel drag operation */
+    cancelDrag: () => void;
+    /** Reorder items in array */
+    reorderItems: <T extends MediaItem>(items: T[], fromIndex: number, toIndex: number) => T[];
+    /** Get drag props for an item */
+    getDragProps: (item: MediaItem, index: number) => {
+        draggable: boolean;
+        'data-index': number;
+        onDragstart: (e: globalThis.DragEvent) => void;
+        onDragover: (e: globalThis.DragEvent) => void;
+        onDragend: () => void;
+        onDrop: (e: globalThis.DragEvent) => void;
+    };
+}
+/**
+ * Composable for drag-and-drop sorting
+ */
+export declare function useMediaDragSort(options?: UseMediaDragSortOptions): UseMediaDragSortReturn;
+export default useMediaDragSort;

package/dist/composables/useMediaSelection.d.ts

@@ -0,0 +1,27 @@
+import { type Ref } from 'vue';
+import type { Media } from '../types/media';
+export interface SelectionEvent {
+    type: 'selection:changed';
+    count: number;
+    selectedIds: string[];
+}
+export declare function useMediaSelection(items: Ref<Media[]>): {
+    selectedIds: import("vue").ComputedRef<Set<string> & Omit<Set<string>, keyof Set<any>>>;
+    selectedItems: import("vue").ComputedRef<Media[]>;
+    selectedCount: import("vue").ComputedRef<number>;
+    isAllSelected: import("vue").ComputedRef<boolean>;
+    isSomeSelected: import("vue").ComputedRef<boolean>;
+    lastSelectedId: import("vue").ComputedRef<string | null>;
+    isSelected: (uuid: string) => boolean;
+    toggle: (uuid: string) => void;
+    select: (uuid: string) => void;
+    deselect: (uuid: string) => void;
+    selectAll: () => void;
+    clear: () => void;
+    toggleAll: () => void;
+    rangeSelect: (targetUuid: string, event?: MouseEvent) => void;
+    selectNext: () => void;
+    selectPrevious: () => void;
+    handleKeydown: (event: KeyboardEvent) => void;
+    selectionBus: import("@vueuse/core").UseEventBusReturn<SelectionEvent, any>;
+};

package/dist/composables/useMediaUploadQueue.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Media Upload Queue Composable
+ * Manages concurrent uploads with progress tracking
+ */
+import { type Ref, type ComputedRef } from 'vue';
+import type { Media } from '../types/media';
+import type { UploadProgress, MediaItem, ValidationRules } from '../types/collection';
+import type { StorageAdapter } from '../types/adapter';
+/**
+ * Options for useMediaUploadQueue
+ */
+export interface UseMediaUploadQueueOptions {
+    /** Storage adapter to use */
+    adapter: StorageAdapter;
+    /** Maximum concurrent uploads */
+    maxConcurrent?: number;
+    /** Validation rules */
+    rules?: ValidationRules;
+    /** Collection name for uploads */
+    collection?: string;
+    /** Callbacks */
+    onUploadStart?: (upload: UploadProgress) => void;
+    onUploadProgress?: (upload: UploadProgress) => void;
+    onUploadComplete?: (upload: UploadProgress, media: Media) => void;
+    onUploadError?: (upload: UploadProgress, error: Error) => void;
+    onQueueComplete?: () => void;
+}
+/**
+ * Return type for useMediaUploadQueue
+ */
+export interface UseMediaUploadQueueReturn {
+    /** Current uploads (both pending and active) */
+    uploads: Ref<Map<string, UploadProgress>>;
+    /** Whether there are active uploads */
+    isUploading: ComputedRef<boolean>;
+    /** Number of active uploads */
+    activeCount: ComputedRef<number>;
+    /** Number of pending uploads */
+    pendingCount: ComputedRef<number>;
+    /** Whether all uploads are complete */
+    isComplete: ComputedRef<boolean>;
+    /** Add files to the upload queue */
+    addFiles: (files: FileList | File[]) => Promise<MediaItem[]>;
+    /** Cancel an upload */
+    cancelUpload: (uploadId: string) => void;
+    /** Retry a failed upload */
+    retryUpload: (uploadId: string) => Promise<void>;
+    /** Clear completed/errored uploads */
+    clearCompleted: () => void;
+    /** Clear all uploads */
+    clearAll: () => void;
+    /** Get upload by ID */
+    getUpload: (uploadId: string) => UploadProgress | undefined;
+    /** All uploads as array */
+    uploadsArray: ComputedRef<UploadProgress[]>;
+}
+/**
+ * Composable for managing media upload queue
+ */
+export declare function useMediaUploadQueue(options: UseMediaUploadQueueOptions): UseMediaUploadQueueReturn;
+export default useMediaUploadQueue;

package/dist/composables/useMediaValidation.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Media Validation Composable
+ * Client-side validation for files before upload
+ */
+import { type Ref } from 'vue';
+import type { ValidationRules, ValidationResult } from '../types/collection';
+/**
+ * Format bytes to human-readable size
+ */
+export declare function formatFileSize(bytes: number): string;
+/**
+ * Get file extension from filename
+ */
+export declare function getFileExtension(filename: string): string;
+/**
+ * Check if file is an image
+ */
+export declare function isImageFile(file: File): boolean;
+/**
+ * Get image dimensions from file
+ */
+export declare function getImageDimensions(file: File): Promise<{
+    width: number;
+    height: number;
+} | null>;
+/**
+ * Validate a single file against rules
+ */
+export declare function validateFile(file: File, rules: ValidationRules): Promise<ValidationResult>;
+/**
+ * Options for useMediaValidation
+ */
+export interface UseMediaValidationOptions {
+    rules?: ValidationRules;
+}
+/**
+ * Return type for useMediaValidation
+ */
+export interface UseMediaValidationReturn {
+    /** Reactive validation rules */
+    rules: Ref<ValidationRules>;
+    /** Update validation rules */
+    setRules: (newRules: ValidationRules) => void;
+    /** Validate a single file */
+    validateFile: (file: File) => Promise<ValidationResult>;
+    /** Validate multiple files */
+    validateFiles: (files: File[]) => Promise<Map<File, ValidationResult>>;
+    /** Check if adding more files would exceed max items */
+    canAddFiles: (count: number, currentCount: number) => boolean;
+    /** Get human-readable accept string for file input */
+    acceptString: Ref<string>;
+    /** Check if a MIME type is allowed */
+    isMimeTypeAllowed: (mimeType: string) => boolean;
+}
+/**
+ * Composable for media validation
+ */
+export declare function useMediaValidation(options?: UseMediaValidationOptions): UseMediaValidationReturn;
+export default useMediaValidation;

package/dist/composables/useRadialMenu.d.ts

@@ -0,0 +1,116 @@
+export interface FilterCategory {
+    id: string;
+    name: string;
+    icon: string;
+    color: string;
+    filters: Filter[];
+}
+export interface Filter {
+    id: string;
+    name: string;
+    type: 'adjustment' | 'effect' | 'artistic';
+    params: Record<string, FilterParam>;
+    preview?: string;
+}
+export interface FilterParam {
+    type: 'range' | 'color' | 'boolean';
+    default: number | string | boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+}
+export interface MenuState {
+    isVisible: boolean;
+    centerPoint: {
+        x: number;
+        y: number;
+    };
+    activeCategory: number | null;
+    activeFilter: string | null;
+    menuLevel: 1 | 2 | 3;
+    rotationAngle: number;
+    isRotating: boolean;
+}
+export declare function useRadialMenu(): {
+    isMenuVisible: import("vue").ComputedRef<boolean>;
+    menuCenter: import("vue").ComputedRef<{
+        x: number;
+        y: number;
+    }>;
+    activeCategory: import("vue").ComputedRef<number | null>;
+    activeFilter: import("vue").ComputedRef<string | null>;
+    menuLevel: import("vue").ComputedRef<2 | 1 | 3>;
+    hoveredCategory: import("vue").Ref<number | null, number | null>;
+    filterCategories: FilterCategory[];
+    subMenuFilters: import("vue").ComputedRef<Filter[]>;
+    currentFilter: import("vue").ComputedRef<Filter | null>;
+    appliedFilters: import("vue").Ref<{
+        filter: {
+            id: string;
+            name: string;
+            type: "adjustment" | "effect" | "artistic";
+            params: Record<string, FilterParam>;
+            preview?: string | undefined;
+        };
+        params: Record<string, any>;
+    }[], {
+        filter: Filter;
+        params: Record<string, any>;
+    }[] | {
+        filter: {
+            id: string;
+            name: string;
+            type: "adjustment" | "effect" | "artistic";
+            params: Record<string, FilterParam>;
+            preview?: string | undefined;
+        };
+        params: Record<string, any>;
+    }[]>;
+    currentFilterParams: import("vue").Ref<Record<string, any>, Record<string, any>>;
+    showMenu: (point: {
+        x: number;
+        y: number;
+    }) => void;
+    hideMenu: () => void;
+    setActiveCategory: (index: number | null) => void;
+    selectFilter: (filter: Filter) => void;
+    updateFilterParam: (paramName: string, value: any) => void;
+    applyCurrentFilter: () => {
+        id: string;
+        name: string;
+        params: {
+            [x: string]: any;
+        };
+    } | null;
+    cancelCurrentFilter: () => void;
+    undoLastFilter: () => {
+        filter: {
+            id: string;
+            name: string;
+            type: "adjustment" | "effect" | "artistic";
+            params: Record<string, FilterParam>;
+            preview?: string | undefined;
+        };
+        params: Record<string, any>;
+    } | null | undefined;
+    clearAllFilters: () => {
+        filter: {
+            id: string;
+            name: string;
+            type: "adjustment" | "effect" | "artistic";
+            params: Record<string, FilterParam>;
+            preview?: string | undefined;
+        };
+        params: Record<string, any>;
+    }[];
+    getRotationAngle: (center: {
+        x: number;
+        y: number;
+    }, touch: {
+        x: number;
+        y: number;
+    }) => number;
+    snapToCategory: (angle: number) => number;
+    getCategoryFromAngle: (angle: number) => number;
+};

package/dist/composables/useSanctumClient.d.ts

@@ -0,0 +1,31 @@
+import { AxiosRequestConfig } from 'axios';
+import { Ref } from 'vue';
+export interface SanctumClientOptions extends Omit<AxiosRequestConfig, 'url'> {
+}
+/**
+ * Configure the global axios instance for the Sanctum client
+ * This should be called once during app initialization
+ */
+export declare function configureSanctumClient(config: {
+    baseURL: string;
+    withCredentials?: boolean;
+    headers?: Record<string, string>;
+}): void;
+/**
+ * Interface for the Sanctum client function with attached reactive properties
+ */
+interface SanctumClientFunction {
+    <T = any>(url: string, options?: SanctumClientOptions): Promise<T>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+}
+/**
+ * Composable for making authenticated HTTP requests with Laravel Sanctum
+ * Provides proper CSRF handling, authentication, and error management
+ */
+export declare function useSanctumClient(): SanctumClientFunction;
+/**
+ * Direct export for simple usage without composable features
+ */
+export declare function sanctumClient<T = any>(url: string, options?: SanctumClientOptions): Promise<T>;
+export {};