@strands.gg/accui 2.17.59 → 2.17.61

package/dist/vue/composables/useModalStack.d.ts

@@ -0,0 +1,86 @@
+import { ModalInstance } from '../utils/modalStack';
+export interface UseModalOptions {
+    closeOnEscape?: boolean;
+    priority?: 'low' | 'normal' | 'high' | 'critical';
+    component?: string;
+}
+export declare function useModalStack(options?: UseModalOptions): {
+    isOpen: import('vue').Ref<boolean, boolean>;
+    modalId: import('vue').Ref<symbol, symbol>;
+    modalInstance: import('vue').Ref<{
+        id: symbol;
+        closeModal: () => void;
+        closeOnEscape: boolean;
+        zIndex: number;
+        component?: string;
+        priority?: "low" | "normal" | "high" | "critical";
+    }, ModalInstance | {
+        id: symbol;
+        closeModal: () => void;
+        closeOnEscape: boolean;
+        zIndex: number;
+        component?: string;
+        priority?: "low" | "normal" | "high" | "critical";
+    }>;
+    openModal: (customCloseHandler?: () => void) => Promise<ModalInstance>;
+    closeModal: () => void;
+    getModalContainer: () => Element | null;
+    getModalBackdrop: () => Element | null;
+    zIndex: () => number;
+    isTopModal: () => boolean;
+};
+export declare function useModalTeleport(modalId: symbol): {
+    target: string;
+    isAvailable: () => boolean;
+};
+export declare function useGlobalModalStack(): {
+    state: import('vue').Ref<{
+        modals: {
+            id: symbol;
+            closeModal: () => void;
+            closeOnEscape: boolean;
+            zIndex: number;
+            component?: string;
+            priority?: "low" | "normal" | "high" | "critical";
+        }[];
+        topModal: {
+            id: symbol;
+            closeModal: () => void;
+            closeOnEscape: boolean;
+            zIndex: number;
+            component?: string;
+            priority?: "low" | "normal" | "high" | "critical";
+        };
+        hasModals: boolean;
+        highestZIndex: number;
+    }, import('../utils/modalStack').ModalStackState | {
+        modals: {
+            id: symbol;
+            closeModal: () => void;
+            closeOnEscape: boolean;
+            zIndex: number;
+            component?: string;
+            priority?: "low" | "normal" | "high" | "critical";
+        }[];
+        topModal: {
+            id: symbol;
+            closeModal: () => void;
+            closeOnEscape: boolean;
+            zIndex: number;
+            component?: string;
+            priority?: "low" | "normal" | "high" | "critical";
+        };
+        hasModals: boolean;
+        highestZIndex: number;
+    }>;
+    closeAll: () => void;
+    closeTop: () => void;
+    getModalByComponent: (componentName: string) => {
+        id: symbol;
+        closeModal: () => void;
+        closeOnEscape: boolean;
+        zIndex: number;
+        component?: string;
+        priority?: "low" | "normal" | "high" | "critical";
+    };
+};

package/dist/vue/composables/useOAuthProviders.d.ts

@@ -0,0 +1,73 @@
+export interface OAuthProvider {
+    id: string;
+    name: string;
+    displayName?: string;
+    icon?: string;
+    iconUrl?: string;
+    auth_url: string;
+    scopes: string[];
+    enabled: boolean;
+    metadata?: Record<string, string>;
+}
+export interface OAuthProvidersResponse {
+    providers: OAuthProvider[];
+    redirect_url: string;
+}
+export interface OAuthProviderDetailsResponse {
+    success: boolean;
+    data: {
+        provider: OAuthProvider;
+        authUrl: string;
+        state?: string;
+    };
+    error?: {
+        code: string;
+        message: string;
+        details?: any;
+    };
+}
+export interface UseOAuthProvidersOptions {
+    redirectUrl?: string;
+    scopes?: string[];
+}
+export declare function useOAuthProviders(options?: UseOAuthProvidersOptions): {
+    providers: import('vue').ComputedRef<{
+        id: string;
+        name: string;
+        displayName?: string;
+        icon?: string;
+        iconUrl?: string;
+        auth_url: string;
+        scopes: string[];
+        enabled: boolean;
+        metadata?: Record<string, string>;
+    }[]>;
+    enabledProviders: import('vue').ComputedRef<{
+        id: string;
+        name: string;
+        displayName?: string;
+        icon?: string;
+        iconUrl?: string;
+        auth_url: string;
+        scopes: string[];
+        enabled: boolean;
+        metadata?: Record<string, string>;
+    }[]>;
+    loading: import('vue').ComputedRef<boolean>;
+    error: import('vue').ComputedRef<string>;
+    fetchProviders: () => Promise<OAuthProvider[]>;
+    getProviderAuthUrl: (providerId: string, customOptions?: Partial<UseOAuthProvidersOptions>) => Promise<string>;
+    redirectToProvider: (providerId: string, customOptions?: Partial<UseOAuthProvidersOptions>) => Promise<void>;
+    getProviderById: (providerId: string) => {
+        id: string;
+        name: string;
+        displayName?: string;
+        icon?: string;
+        iconUrl?: string;
+        auth_url: string;
+        scopes: string[];
+        enabled: boolean;
+        metadata?: Record<string, string>;
+    };
+    getProviderIcon: (provider: OAuthProvider) => string;
+};

package/dist/vue/composables/useStrandsAuth.d.ts

@@ -0,0 +1,2 @@
+import { UseStrandsAuthReturn } from '../../types';
+export declare function useStrandsAuth(): UseStrandsAuthReturn;

package/dist/vue/composables/useStrandsConfig.d.ts

@@ -0,0 +1,5 @@
+import { StrandsAuthConfig, UseStrandsConfigReturn } from '../../types';
+export type { StrandsAuthConfig, StrandsAuthEndpoints } from '../../types';
+export declare function provideStrandsConfig(config: StrandsAuthConfig): void;
+export declare function useStrandsConfig(fallbackConfig?: Partial<StrandsAuthConfig>): UseStrandsConfigReturn;
+export declare function setStrandsConfig(config: StrandsAuthConfig): void;

package/dist/vue/composables/useStrandsMfa.d.ts

@@ -0,0 +1,36 @@
+import { MfaDevicesResponse, TotpSetupResponse, BackupCodesResponse } from '../../types';
+export declare function useStrandsMfa(): {
+    mfaDevices: import('vue').ComputedRef<{
+        id: string;
+        device_type: import('../..').MfaDeviceType;
+        device_name: string;
+        is_active: boolean;
+        last_used_at?: string | Date;
+        created_at: string | Date;
+    }[]>;
+    mfaEnabled: import('vue').ComputedRef<boolean>;
+    loading: import('vue').ComputedRef<boolean>;
+    hasMfaDevices: import('vue').ComputedRef<boolean>;
+    activeMfaDevices: import('vue').ComputedRef<{
+        id: string;
+        device_type: import('../..').MfaDeviceType;
+        device_name: string;
+        is_active: boolean;
+        last_used_at?: string | Date;
+        created_at: string | Date;
+    }[]>;
+    fetchMfaDevices: () => Promise<MfaDevicesResponse>;
+    setupTotp: (deviceName: string) => Promise<TotpSetupResponse>;
+    verifyTotpSetup: (deviceId: string, totpCode: string) => Promise<void>;
+    setupEmailMfa: (deviceName: string) => Promise<{
+        device_id: string;
+        email: string;
+    }>;
+    sendEmailMfaCode: (deviceId: string) => Promise<void>;
+    verifyEmailMfaCode: (deviceId: string, code: string) => Promise<boolean>;
+    disableMfaDevice: (deviceId: string) => Promise<void>;
+    regenerateBackupCodes: (deviceId: string) => Promise<BackupCodesResponse>;
+    getDeviceTypeIcon: (deviceType: string) => string;
+    getDeviceTypeName: (deviceType: string) => string;
+    formatLastUsed: (lastUsedAt?: string | Date) => string;
+};

package/dist/vue/composables/useStrandsOAuth.d.ts

@@ -0,0 +1,10 @@
+import { StrandsOAuthConfig, UseStrandsOAuthReturn } from '../../types';
+/**
+ * Composable for OAuth2 authentication with Strands Auth
+ *
+ * This composable handles the OAuth2 Authorization Code flow with PKCE
+ * for third-party applications integrating with Strands Auth.
+ *
+ * @param config - OAuth2 client configuration
+ */
+export declare function useStrandsOAuth(config: StrandsOAuthConfig): UseStrandsOAuthReturn;

package/dist/vue/composables/useTheme.d.ts

@@ -0,0 +1,18 @@
+import { ComputedRef } from 'vue';
+/**
+ * Composable for theme management
+ *
+ * Checks for UiApp theme provider and returns the appropriate theme
+ * If UiApp forces a theme (not 'auto'), all components must use that theme
+ */
+export declare function useTheme(fallbackTheme?: 'light' | 'dark' | 'auto'): {
+    theme: ComputedRef<"light" | "dark" | "auto">;
+    isDark: ComputedRef<boolean>;
+    isLight: ComputedRef<boolean>;
+    isForced: ComputedRef<boolean>;
+    themeClass: ComputedRef<{
+        'ui-theme--light': boolean;
+        'ui-theme--dark': boolean;
+        'ui-theme--forced': boolean;
+    }>;
+};

package/dist/vue/index.d.ts

@@ -0,0 +1,16 @@
+export * from './components/index';
+export * from './ui/index';
+export { default as StrandsUIPlugin, injectSquircleStyles } from './plugins/StrandsUIPlugin';
+export * from './composables/useStrandsAuth';
+export * from './composables/useStrandsConfig';
+export * from './composables/useOAuthProviders';
+export * from './composables/useAuthenticatedFetch';
+export * from './composables/useDarkMode';
+export * from './composables/useTheme';
+export * from './composables/useFloatingPosition';
+export * from './composables/useModalStack';
+export * from './utils/requestCache';
+export * from './utils/debounce';
+export * from './utils/fontPreloader';
+export * from './utils/lazyComponents';
+export * from './utils/performanceInit';

package/dist/vue/plugins/StrandsUIPlugin.d.ts

@@ -0,0 +1,19 @@
+import { App } from 'vue';
+import { default as StrandsUiAlert } from '../ui/UiAlert.vue';
+import { default as StrandsUiButton } from '../ui/UiButton.vue';
+import { default as StrandsUiCard } from '../ui/UiCard.vue';
+import { default as StrandsUiInput } from '../ui/UiInput.vue';
+import { default as StrandsUiLink } from '../ui/UiLink.vue';
+import { default as StrandsUiTabs } from '../ui/UiTabs.vue';
+import { default as StrandsUiLoader } from '../ui/UiLoader.vue';
+declare function injectSquircleStyles(): void;
+export interface StrandsUIOptions {
+    prefix?: string;
+}
+declare const _default: {
+    install(app: App, options?: StrandsUIOptions): void;
+};
+export default _default;
+export { StrandsUiAlert, StrandsUiButton, StrandsUiCard, StrandsUiInput, StrandsUiLink, StrandsUiTabs, StrandsUiLoader, };
+export { injectSquircleStyles };
+export type { ButtonVariant, ButtonSize, InputType, CardVariant, LinkVariant, AlertVariant, } from '../ui/index';

package/dist/vue/ui/UiAlert.vue.d.ts

@@ -0,0 +1,30 @@
+interface Props {
+    variant?: 'success' | 'error' | 'warning' | 'info';
+    title?: string;
+    message?: string;
+    dismissible?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    dismiss: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onDismiss?: () => any;
+}>, {
+    variant: "success" | "error" | "warning" | "info";
+    dismissible: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/vue/ui/UiApp.vue.d.ts

@@ -0,0 +1,26 @@
+interface Props {
+    theme?: 'light' | 'dark' | 'auto';
+    loading?: boolean;
+    loadingMessage?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    theme: "light" | "dark" | "auto";
+    loading: boolean;
+    loadingMessage: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/vue/ui/UiAvatarEditor.vue.d.ts

@@ -0,0 +1,24 @@
+interface Props {
+    size?: number;
+    previewSize?: number;
+    maxFileSize?: number;
+    uploading?: boolean;
+    preselectedFile?: File | null;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    error: (error: string) => any;
+    upload: (file: File) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onError?: (error: string) => any;
+    onUpload?: (file: File) => any;
+}>, {
+    size: number;
+    maxFileSize: number;
+    previewSize: number;
+    uploading: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    fileInput: HTMLInputElement;
+    canvas: HTMLCanvasElement;
+    previewCanvas: HTMLCanvasElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/vue/ui/UiButton/UiButton.Anchor.vue.d.ts

@@ -0,0 +1,42 @@
+interface Props {
+    to?: string | object;
+    href?: string;
+    external?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    loadingText?: string;
+    icon?: boolean;
+    buttonClasses?: string[];
+    buttonStyles?: Record<string, any>;
+    textAlign?: 'start' | 'center' | 'end';
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'leading-icon'?(_: {}): any;
+        icon?(_: {}): any;
+        default?(_: {}): any;
+        'trailing-icon'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLAnchorElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: (event: MouseEvent) => any;
+}>, {
+    loading: boolean;
+    disabled: boolean;
+    icon: boolean;
+    textAlign: "start" | "center" | "end";
+    external: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLAnchorElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/vue/ui/UiButton/UiButton.Content.vue.d.ts

@@ -0,0 +1,32 @@
+interface Props {
+    loading?: boolean;
+    loadingText?: string;
+    icon?: boolean;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    textAlign?: 'start' | 'center' | 'end';
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        icon?(_: {}): any;
+        'leading-icon'?(_: {}): any;
+        default?(_: {}): any;
+        'trailing-icon'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    loading: boolean;
+    icon: boolean;
+    textAlign: "start" | "center" | "end";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/vue/ui/UiButton/UiButton.Nuxt.vue.d.ts

@@ -0,0 +1,39 @@
+interface Props {
+    to: string | object;
+    disabled?: boolean;
+    loading?: boolean;
+    loadingText?: string;
+    icon?: boolean;
+    buttonClasses?: string[];
+    buttonStyles?: Record<string, any>;
+    textAlign?: 'start' | 'center' | 'end';
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'leading-icon'?(_: {}): any;
+        icon?(_: {}): any;
+        default?(_: {}): any;
+        'trailing-icon'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: (event: MouseEvent) => any;
+}>, {
+    loading: boolean;
+    disabled: boolean;
+    icon: boolean;
+    textAlign: "start" | "center" | "end";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/vue/ui/UiButton/index.d.ts

@@ -0,0 +1,11 @@
+import { default as UiButton } from '../UiButton.vue';
+import { default as UiButtonContent } from './UiButton.Content.vue';
+import { default as UiButtonAnchor } from './UiButton.Anchor.vue';
+import { default as UiButtonNuxt } from './UiButton.Nuxt.vue';
+declare const CompoundUiButton: typeof UiButton & {
+    Content: typeof UiButtonContent;
+    Anchor: typeof UiButtonAnchor;
+    Nuxt: typeof UiButtonNuxt;
+};
+export default CompoundUiButton;
+export { UiButtonContent, UiButtonAnchor, UiButtonNuxt };

package/dist/vue/ui/UiButton.vue.d.ts

@@ -0,0 +1,77 @@
+import { UiTooltipProps } from './UiTooltip.vue';
+export interface UiButtonProps {
+    variant?: 'primary' | 'secondary' | 'ghost' | 'outline' | 'default';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    type?: 'button' | 'submit' | 'reset';
+    disabled?: boolean;
+    loading?: boolean;
+    loadingText?: string;
+    fullWidth?: boolean;
+    color?: 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'info';
+    fontWeight?: 400 | 500 | 600 | 700;
+    icon?: boolean;
+    squircle?: boolean;
+    to?: string | object;
+    href?: string;
+    external?: boolean;
+    tabindex?: number;
+    title?: string | UiTooltipProps;
+    textAlign?: 'start' | 'center' | 'end';
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'leading-icon'?(_: {}): any;
+        'leading-icon'?(_: {}): any;
+        'leading-icon'?(_: {}): any;
+        'leading-icon'?(_: {}): any;
+        'leading-icon'?(_: {}): any;
+        'leading-icon'?(_: {}): any;
+        icon?(_: {}): any;
+        icon?(_: {}): any;
+        icon?(_: {}): any;
+        icon?(_: {}): any;
+        icon?(_: {}): any;
+        icon?(_: {}): any;
+        default?(_: {}): any;
+        default?(_: {}): any;
+        default?(_: {}): any;
+        default?(_: {}): any;
+        default?(_: {}): any;
+        default?(_: {}): any;
+        'trailing-icon'?(_: {}): any;
+        'trailing-icon'?(_: {}): any;
+        'trailing-icon'?(_: {}): any;
+        'trailing-icon'?(_: {}): any;
+        'trailing-icon'?(_: {}): any;
+        'trailing-icon'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UiButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<UiButtonProps> & Readonly<{
+    onClick?: (event: MouseEvent) => any;
+}>, {
+    loading: boolean;
+    type: "button" | "submit" | "reset";
+    disabled: boolean;
+    variant: "primary" | "secondary" | "ghost" | "outline" | "default";
+    size: "xs" | "sm" | "md" | "lg" | "xl";
+    color: "primary" | "secondary" | "success" | "warning" | "danger" | "info";
+    fullWidth: boolean;
+    icon: boolean;
+    textAlign: "start" | "center" | "end";
+    external: boolean;
+    fontWeight: 400 | 500 | 600 | 700;
+    squircle: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/vue/ui/UiCard.vue.d.ts

@@ -0,0 +1,38 @@
+interface Props {
+    variant?: 'default' | 'modern' | 'minimal' | 'clean' | 'simple';
+    padding?: 'sm' | 'md' | 'lg';
+    shadow?: 'none' | 'sm' | 'md' | 'lg';
+    color?: 'default' | 'secondary' | 'tertiary';
+    title?: string;
+    subtitle?: string;
+    to?: string | object;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        'leading-icon'?(_: {}): any;
+        title?(_: {}): any;
+        subtitle?(_: {}): any;
+        'trailing-icon'?(_: {}): any;
+        actions?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    variant: "default" | "modern" | "minimal" | "clean" | "simple";
+    color: "default" | "secondary" | "tertiary";
+    padding: "sm" | "md" | "lg";
+    shadow: "none" | "sm" | "md" | "lg";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/vue/ui/UiCheckboxGroup.vue.d.ts

@@ -0,0 +1,46 @@
+interface CheckboxOption {
+    value: string | number;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    icon?: any;
+}
+interface Props {
+    modelValue?: (string | number)[];
+    options: CheckboxOption[];
+    label?: string;
+    description?: string;
+    helpText?: string;
+    error?: string | boolean;
+    disabled?: boolean;
+    required?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    variant?: 'default' | 'card';
+    size?: 'sm' | 'md' | 'lg';
+    showSelectAll?: boolean;
+    selectAllLabel?: string;
+    fieldId?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    blur: (event: FocusEvent) => any;
+    change: (value: (string | number)[]) => any;
+    focus: (event: FocusEvent) => any;
+    "update:modelValue": (value: (string | number)[]) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onBlur?: (event: FocusEvent) => any;
+    onChange?: (value: (string | number)[]) => any;
+    onFocus?: (event: FocusEvent) => any;
+    "onUpdate:modelValue"?: (value: (string | number)[]) => any;
+}>, {
+    required: boolean;
+    disabled: boolean;
+    variant: "default" | "card";
+    size: "sm" | "md" | "lg";
+    modelValue: (string | number)[];
+    orientation: "horizontal" | "vertical";
+    fieldId: string;
+    showSelectAll: boolean;
+    selectAllLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;