@moubing/bing-ui 0.1.0 → 0.2.0

package/dist/components/BingForm/BingForm.types.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export type BingControlStatus = 'default' | 'error' | 'success' | 'warning';
+export type BingFormSize = 'sm' | 'md' | 'lg';
+export type BingFormLayout = 'grid' | 'stack' | 'inline';
+export type BingFormLabelPosition = 'top' | 'left';
+export type BingFormValidateTrigger = 'change' | 'blur' | 'submit' | 'manual';
+export type BingFormBreakpoint = 'base' | 'sm' | 'md' | 'lg' | 'xl';
+export type BingFormResponsiveNumber = number | Partial<Record<BingFormBreakpoint, number>>;
+export type BingFormGap = string | number | {
+    row?: string | number;
+    column?: string | number;
+};
+export type BingFormModel = Record<string, unknown>;
+export type BingFormSchema = z.ZodType<unknown>;
+export type BingFormErrors = Record<string, string[]>;
+export interface BingFormProps {
+    model?: BingFormModel;
+    schema?: BingFormSchema;
+    layout?: BingFormLayout;
+    columns?: BingFormResponsiveNumber;
+    gap?: BingFormGap;
+    labelPosition?: BingFormLabelPosition;
+    labelWidth?: string | number;
+    size?: BingFormSize;
+    disabled?: boolean;
+    validateTrigger?: BingFormValidateTrigger | BingFormValidateTrigger[];
+    scrollToError?: boolean;
+}
+export interface BingFormValidationResult {
+    valid: boolean;
+    errors: BingFormErrors;
+}
+export interface BingFormSubmitPayload extends BingFormValidationResult {
+    event: SubmitEvent;
+}
+export interface BingFormEmits {
+    submit: [payload: BingFormSubmitPayload];
+    invalid: [payload: BingFormValidationResult];
+}
+export interface BingFormExpose {
+    validate: () => Promise<boolean>;
+    validateField: (prop: string) => Promise<boolean>;
+    clearValidate: (prop?: string) => void;
+    resetFields: () => void;
+    getErrors: () => BingFormErrors;
+}

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

@@ -0,0 +1,32 @@
+import { BingFormExpose, BingFormGap, BingFormModel, BingFormProps, BingFormResponsiveNumber, BingFormValidateTrigger, BingFormValidationResult } from './BingForm.types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingFormProps, BingFormExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    submit: (payload: import('./BingForm.types').BingFormSubmitPayload) => any;
+    invalid: (payload: BingFormValidationResult) => any;
+}, string, import('vue').PublicProps, Readonly<BingFormProps> & Readonly<{
+    onSubmit?: ((payload: import('./BingForm.types').BingFormSubmitPayload) => any) | undefined;
+    onInvalid?: ((payload: BingFormValidationResult) => any) | undefined;
+}>, {
+    disabled: boolean;
+    columns: BingFormResponsiveNumber;
+    gap: BingFormGap;
+    size: import('./BingForm.types').BingFormSize;
+    model: BingFormModel;
+    schema: import('./BingForm.types').BingFormSchema;
+    layout: import('./BingForm.types').BingFormLayout;
+    labelPosition: import('./BingForm.types').BingFormLabelPosition;
+    labelWidth: string | number;
+    validateTrigger: BingFormValidateTrigger | BingFormValidateTrigger[];
+    scrollToError: boolean;
+}, {}, {}, {}, 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/BingForm/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingForm } from './BingForm.vue';
+export type { BingControlStatus, BingFormBreakpoint, BingFormEmits, BingFormErrors, BingFormExpose, BingFormGap, BingFormLabelPosition, BingFormLayout, BingFormModel, BingFormProps, BingFormResponsiveNumber, BingFormSchema, BingFormSize, BingFormSubmitPayload, BingFormValidateTrigger, BingFormValidationResult, } from './BingForm.types';

package/dist/components/BingFormItem/BingFormItem.types.d.ts

@@ -0,0 +1,10 @@
+import { BingFormLabelPosition, BingFormResponsiveNumber } from '../BingForm/BingForm.types';
+export interface BingFormItemProps {
+    prop?: string;
+    label?: string;
+    required?: boolean;
+    span?: BingFormResponsiveNumber;
+    help?: string;
+    showMessage?: boolean;
+    labelPosition?: BingFormLabelPosition;
+}

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

@@ -0,0 +1,30 @@
+import { BingFormResponsiveNumber } from '../BingForm/BingForm.types';
+import { BingFormItemProps } from './BingFormItem.types';
+declare var __VLS_1: {
+    id: string;
+    status: string;
+    'aria-describedby': string | undefined;
+    invalid: boolean;
+    disabled: boolean;
+    size: import('..').BingFormSize;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingFormItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BingFormItemProps> & Readonly<{}>, {
+    label: string;
+    span: BingFormResponsiveNumber;
+    required: boolean;
+    prop: string;
+    labelPosition: import('..').BingFormLabelPosition;
+    help: string;
+    showMessage: boolean;
+}, {}, {}, {}, 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/BingFormItem/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingFormItem } from './BingFormItem.vue';
+export type { BingFormItemProps } from './BingFormItem.types';

package/dist/components/BingIcon/BingIcon.types.d.ts

@@ -0,0 +1,11 @@
+import { Component } from 'vue';
+export type BingIconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number | `${number}px`;
+export type BingIconTone = 'inherit' | 'muted' | 'primary' | 'secondary' | 'danger' | 'success' | 'warning';
+export interface BingIconProps {
+    icon: Component;
+    size?: BingIconSize;
+    tone?: BingIconTone;
+    strokeWidth?: number;
+    decorative?: boolean;
+    label?: string;
+}

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

@@ -0,0 +1,10 @@
+import { BingIconProps, BingIconSize } from './BingIcon.types';
+declare const __VLS_export: import('vue').DefineComponent<BingIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BingIconProps> & Readonly<{}>, {
+    strokeWidth: number;
+    label: string;
+    size: BingIconSize;
+    tone: import('./BingIcon.types').BingIconTone;
+    decorative: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/BingIcon/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingIcon } from './BingIcon.vue';
+export type { BingIconProps, BingIconSize, BingIconTone } from './BingIcon.types';

package/dist/components/BingImage/BingImage.types.d.ts

@@ -0,0 +1,68 @@
+import { BingImagePreviewItem } from '../BingImagePreview/BingImagePreview.types';
+export type BingImageFit = 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
+export type BingImageRadius = 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+export type BingImageLoading = 'lazy' | 'eager';
+export type BingImageDecoding = 'async' | 'sync' | 'auto';
+export type BingImageFetchPriority = 'high' | 'low' | 'auto';
+export type BingImageCrossOrigin = '' | 'anonymous' | 'use-credentials';
+export type BingImageReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+export type BingImageStatus = 'idle' | 'loading' | 'loaded' | 'error';
+export interface BingImageProps {
+    src?: string;
+    alt?: string;
+    srcset?: string;
+    sizes?: string;
+    width?: number | string;
+    height?: number | string;
+    aspectRatio?: number | string;
+    fit?: BingImageFit;
+    position?: string;
+    radius?: BingImageRadius;
+    block?: boolean;
+    loading?: BingImageLoading;
+    decoding?: BingImageDecoding;
+    fetchPriority?: BingImageFetchPriority;
+    fallbackSrc?: string;
+    placeholderSrc?: string;
+    showLoading?: boolean;
+    showError?: boolean;
+    errorText?: string;
+    crossorigin?: BingImageCrossOrigin;
+    referrerPolicy?: BingImageReferrerPolicy;
+    preview?: boolean;
+    previewSrc?: string;
+    previewItems?: BingImagePreviewItem[];
+    previewInitialIndex?: number;
+    previewDownloadable?: boolean;
+    previewDownloadUrl?: string;
+    previewDownloadName?: string;
+    previewAriaLabel?: string;
+}
+export interface BingImageLoadPayload {
+    event: Event;
+    src: string;
+    naturalWidth: number;
+    naturalHeight: number;
+}
+export interface BingImageErrorPayload {
+    event: Event;
+    src: string;
+    isFallback: boolean;
+}
+export interface BingImageStatusChangePayload {
+    status: BingImageStatus;
+    src?: string;
+}
+export interface BingImagePreviewOpenPayload {
+    src: string;
+}
+export interface BingImagePreviewClosePayload {
+    reason: 'close' | 'overlay' | 'escape';
+}
+export interface BingImageEmits {
+    load: [payload: BingImageLoadPayload];
+    error: [payload: BingImageErrorPayload];
+    statusChange: [payload: BingImageStatusChangePayload];
+    previewOpen: [payload: BingImagePreviewOpenPayload];
+    previewClose: [payload: BingImagePreviewClosePayload];
+}

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

@@ -0,0 +1,64 @@
+import { BingImageProps } from './BingImage.types';
+declare function retry(): void;
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {
+    src: string | undefined;
+    retry: typeof retry;
+};
+type __VLS_Slots = {} & {
+    placeholder?: (props: typeof __VLS_1) => any;
+} & {
+    loading?: (props: typeof __VLS_3) => any;
+} & {
+    error?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingImageProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (payload: import('./BingImage.types').BingImageErrorPayload) => any;
+    load: (payload: import('./BingImage.types').BingImageLoadPayload) => any;
+    statusChange: (payload: import('./BingImage.types').BingImageStatusChangePayload) => any;
+    previewOpen: (payload: import('./BingImage.types').BingImagePreviewOpenPayload) => any;
+    previewClose: (payload: import('./BingImage.types').BingImagePreviewClosePayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingImageProps> & Readonly<{
+    onError?: ((payload: import('./BingImage.types').BingImageErrorPayload) => any) | undefined;
+    onLoad?: ((payload: import('./BingImage.types').BingImageLoadPayload) => any) | undefined;
+    onStatusChange?: ((payload: import('./BingImage.types').BingImageStatusChangePayload) => any) | undefined;
+    onPreviewOpen?: ((payload: import('./BingImage.types').BingImagePreviewOpenPayload) => any) | undefined;
+    onPreviewClose?: ((payload: import('./BingImage.types').BingImagePreviewClosePayload) => any) | undefined;
+}>, {
+    height: number | string;
+    position: string;
+    width: number | string;
+    block: boolean;
+    loading: import('./BingImage.types').BingImageLoading;
+    radius: import('./BingImage.types').BingImageRadius;
+    aspectRatio: number | string;
+    src: string;
+    alt: string;
+    previewSrc: string;
+    srcset: string;
+    sizes: string;
+    fit: import('./BingImage.types').BingImageFit;
+    decoding: import('./BingImage.types').BingImageDecoding;
+    fetchPriority: import('./BingImage.types').BingImageFetchPriority;
+    fallbackSrc: string;
+    placeholderSrc: string;
+    showLoading: boolean;
+    showError: boolean;
+    errorText: string;
+    crossorigin: import('./BingImage.types').BingImageCrossOrigin;
+    referrerPolicy: import('./BingImage.types').BingImageReferrerPolicy;
+    preview: boolean;
+    previewItems: import('..').BingImagePreviewItem[];
+    previewInitialIndex: number;
+    previewDownloadable: boolean;
+    previewDownloadUrl: string;
+    previewDownloadName: string;
+    previewAriaLabel: string;
+}, {}, {}, {}, 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/BingImage/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingImage } from './BingImage.vue';
+export type { BingImageCrossOrigin, BingImageDecoding, BingImageEmits, BingImageErrorPayload, BingImageFetchPriority, BingImageFit, BingImageLoadPayload, BingImageLoading, BingImagePreviewClosePayload, BingImagePreviewOpenPayload, BingImageProps, BingImageRadius, BingImageReferrerPolicy, BingImageStatus, BingImageStatusChangePayload, } from './BingImage.types';

package/dist/components/BingImagePreview/BingImagePreview.types.d.ts

@@ -0,0 +1,40 @@
+import { BingGlassEffectProps } from '../../utils/glass';
+export interface BingImagePreviewItem {
+    src: string;
+    alt?: string;
+    previewSrc?: string;
+    downloadUrl?: string;
+    downloadName?: string;
+    caption?: string;
+}
+export type BingImagePreviewCloseReason = 'close' | 'overlay' | 'escape';
+export interface BingImagePreviewProps extends BingGlassEffectProps {
+    modelValue?: boolean;
+    items?: BingImagePreviewItem[];
+    initialIndex?: number;
+    currentIndex?: number;
+    zIndex?: number;
+    minScale?: number;
+    maxScale?: number;
+    zoomStep?: number;
+    downloadable?: boolean;
+    loop?: boolean;
+    lockScroll?: boolean;
+    closeOnEsc?: boolean;
+    closeOnOverlay?: boolean;
+    showToolbar?: boolean;
+    showCounter?: boolean;
+    teleportTo?: string | HTMLElement;
+    ariaLabel?: string;
+}
+export interface BingImagePreviewDownloadPayload {
+    item: BingImagePreviewItem;
+    index: number;
+}
+export interface BingImagePreviewEmits {
+    'update:modelValue': [value: boolean];
+    'update:currentIndex': [value: number];
+    close: [reason: BingImagePreviewCloseReason];
+    change: [index: number, item: BingImagePreviewItem];
+    download: [payload: BingImagePreviewDownloadPayload];
+}

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

@@ -0,0 +1,38 @@
+import { BingImagePreviewCloseReason, BingImagePreviewProps } from './BingImagePreview.types';
+declare const __VLS_export: import('vue').DefineComponent<BingImagePreviewProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    change: (index: number, item: import('./BingImagePreview.types').BingImagePreviewItem) => any;
+    close: (reason: BingImagePreviewCloseReason) => any;
+    "update:currentIndex": (value: number) => any;
+    download: (payload: import('./BingImagePreview.types').BingImagePreviewDownloadPayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingImagePreviewProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onChange?: ((index: number, item: import('./BingImagePreview.types').BingImagePreviewItem) => any) | undefined;
+    onClose?: ((reason: BingImagePreviewCloseReason) => any) | undefined;
+    "onUpdate:currentIndex"?: ((value: number) => any) | undefined;
+    onDownload?: ((payload: import('./BingImagePreview.types').BingImagePreviewDownloadPayload) => any) | undefined;
+}>, {
+    zIndex: number;
+    glass: boolean;
+    ariaLabel: string;
+    modelValue: boolean;
+    items: import('./BingImagePreview.types').BingImagePreviewItem[];
+    loop: boolean;
+    glassBlur: string | number;
+    glassOpacity: number;
+    glassSaturation: number;
+    closeOnEsc: boolean;
+    lockScroll: boolean;
+    closeOnOverlay: boolean;
+    initialIndex: number;
+    currentIndex: number;
+    minScale: number;
+    maxScale: number;
+    zoomStep: number;
+    downloadable: boolean;
+    showToolbar: boolean;
+    showCounter: boolean;
+    teleportTo: string | HTMLElement;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/BingImagePreview/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingImagePreview } from './BingImagePreview.vue';
+export type { BingImagePreviewCloseReason, BingImagePreviewDownloadPayload, BingImagePreviewEmits, BingImagePreviewItem, BingImagePreviewProps, } from './BingImagePreview.types';

package/dist/components/BingInput/BingInput.types.d.ts

@@ -0,0 +1,38 @@
+import { Component } from 'vue';
+export type BingInputSize = 'sm' | 'md' | 'lg';
+export type BingInputType = 'text' | 'search' | 'email' | 'password' | 'tel' | 'url';
+export interface BingInputProps {
+    id?: string;
+    modelValue?: string;
+    type?: BingInputType;
+    placeholder?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    icon?: Component;
+    iconLabel?: string;
+    size?: BingInputSize;
+    block?: boolean;
+    debounceDelay?: number;
+    clearAriaLabel?: string;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    status?: 'default' | 'error' | 'success' | 'warning';
+    name?: string;
+    autocomplete?: string;
+    spellcheck?: boolean | 'true' | 'false';
+}
+export interface BingInputEmits {
+    'update:modelValue': [value: string];
+    input: [value: string, event: Event];
+    'debounced-input': [value: string];
+    clear: [];
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+    keydown: [event: KeyboardEvent];
+}
+export interface BingInputExpose {
+    input: HTMLInputElement | null;
+    focus: () => void;
+    blur: () => void;
+    select: () => void;
+}

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

@@ -0,0 +1,49 @@
+import { BingInputExpose, BingInputProps } from './BingInput.types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingInputProps, BingInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: () => any;
+    input: (value: string, event: Event) => any;
+    "update:modelValue": (value: string) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    "debounced-input": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<BingInputProps> & Readonly<{
+    onClear?: (() => any) | undefined;
+    onInput?: ((value: string, event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    "onDebounced-input"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    type: import('./BingInput.types').BingInputType;
+    ariaLabel: string;
+    modelValue: string;
+    size: import('./BingInput.types').BingInputSize;
+    block: boolean;
+    name: string;
+    icon: import('vue').Component;
+    id: string;
+    ariaDescribedby: string;
+    status: "default" | "error" | "success" | "warning";
+    placeholder: string;
+    clearable: boolean;
+    iconLabel: string;
+    debounceDelay: number;
+    clearAriaLabel: string;
+    autocomplete: string;
+    spellcheck: boolean | "true" | "false";
+}, {}, {}, {}, 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/BingInput/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingInput } from './BingInput.vue';
+export type { BingInputEmits, BingInputExpose, BingInputProps, BingInputSize, BingInputType, } from './BingInput.types';

package/dist/components/BingRadio/BingRadio.types.d.ts

@@ -0,0 +1,21 @@
+import { BingRadioGroupSize, BingRadioValue } from '../BingRadioGroup/BingRadioGroup.types';
+export type BingRadioSize = BingRadioGroupSize;
+export interface BingRadioProps {
+    id?: string;
+    modelValue?: BingRadioValue | null;
+    value?: BingRadioValue;
+    disabled?: boolean;
+    size?: BingRadioSize;
+    label?: string;
+    description?: string;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    status?: 'default' | 'error' | 'success' | 'warning';
+    name?: string;
+}
+export interface BingRadioEmits {
+    'update:modelValue': [value: BingRadioValue];
+    change: [value: BingRadioValue, event: Event];
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+}

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

@@ -0,0 +1,38 @@
+import { BingRadioProps } from './BingRadio.types';
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    description?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingRadioProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: import('..').BingRadioValue) => any;
+    change: (value: import('..').BingRadioValue, event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BingRadioProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('..').BingRadioValue) => any) | undefined;
+    onChange?: ((value: import('..').BingRadioValue, event: Event) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    label: string;
+    value: import('..').BingRadioValue;
+    ariaLabel: string;
+    modelValue: import('..').BingRadioValue | null;
+    size: import('./BingRadio.types').BingRadioSize;
+    name: string;
+    description: string;
+    id: string;
+    ariaDescribedby: string;
+    status: "default" | "error" | "success" | "warning";
+}, {}, {}, {}, 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/BingRadio/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingRadio } from './BingRadio.vue';
+export type { BingRadioEmits, BingRadioProps, BingRadioSize, } from './BingRadio.types';

package/dist/components/BingRadioGroup/BingRadioGroup.context.d.ts

@@ -0,0 +1,13 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { BingRadioGroupOption, BingRadioGroupSize, BingRadioValue } from './BingRadioGroup.types';
+export interface BingRadioGroupContext {
+    modelValue: ComputedRef<BingRadioValue | null>;
+    disabled: ComputedRef<boolean>;
+    size: ComputedRef<BingRadioGroupSize>;
+    name: ComputedRef<string>;
+    status: ComputedRef<'default' | 'error' | 'success' | 'warning'>;
+    updateValue: (value: BingRadioValue, event: Event) => void;
+    handleRadioBlur: (event: FocusEvent) => void;
+    isOptionDisabled: (option: Pick<BingRadioGroupOption, 'disabled'>) => boolean;
+}
+export declare const bingRadioGroupContextKey: InjectionKey<BingRadioGroupContext>;

package/dist/components/BingRadioGroup/BingRadioGroup.types.d.ts

@@ -0,0 +1,27 @@
+export type BingRadioValue = string | number | boolean;
+export type BingRadioGroupSize = 'sm' | 'md' | 'lg';
+export type BingRadioGroupDirection = 'row' | 'column' | 'wrap';
+export interface BingRadioGroupOption {
+    label: string;
+    value: BingRadioValue;
+    disabled?: boolean;
+    description?: string;
+}
+export interface BingRadioGroupProps {
+    id?: string;
+    modelValue?: BingRadioValue | null;
+    options?: BingRadioGroupOption[];
+    disabled?: boolean;
+    size?: BingRadioGroupSize;
+    direction?: BingRadioGroupDirection;
+    name?: string;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    status?: 'default' | 'error' | 'success' | 'warning';
+}
+export interface BingRadioGroupEmits {
+    'update:modelValue': [value: BingRadioValue];
+    change: [value: BingRadioValue, event: Event];
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+}

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

@@ -0,0 +1,35 @@
+import { BingRadioGroupOption, BingRadioGroupProps, BingRadioValue } from './BingRadioGroup.types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingRadioGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: BingRadioValue) => any;
+    change: (value: BingRadioValue, event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BingRadioGroupProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: BingRadioValue) => any) | undefined;
+    onChange?: ((value: BingRadioValue, event: Event) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    direction: import('./BingRadioGroup.types').BingRadioGroupDirection;
+    ariaLabel: string;
+    modelValue: BingRadioValue | null;
+    size: import('./BingRadioGroup.types').BingRadioGroupSize;
+    name: string;
+    id: string;
+    ariaDescribedby: string;
+    status: "default" | "error" | "success" | "warning";
+    options: BingRadioGroupOption[];
+}, {}, {}, {}, 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/BingRadioGroup/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingRadioGroup } from './BingRadioGroup.vue';
+export type { BingRadioGroupDirection, BingRadioGroupEmits, BingRadioGroupOption, BingRadioGroupProps, BingRadioGroupSize, BingRadioValue, } from './BingRadioGroup.types';