@mittwald/flow-remote-elements 0.1.0-experimental.285 → 0.2.0-alpha.3

package/dist/types/auto-generated/RemotePopoverTriggerElement.d.ts

@@ -0,0 +1,17 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { PopoverTriggerProps as RemotePopoverTriggerElementProps } from '@mittwald/flow-react-components/Popover';
+export type { PopoverTriggerProps as RemotePopoverTriggerElementProps } from '@mittwald/flow-react-components/Popover';
+export declare class RemotePopoverTriggerElement extends FlowRemoteElement<RemotePopoverTriggerElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        controller: {};
+        isDefaultOpen: {};
+    };
+    static get remoteEvents(): {};
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-popover-trigger": InstanceType<typeof RemotePopoverTriggerElement>;
+    }
+}

package/dist/types/auto-generated/RemoteProgressBarElement.d.ts

@@ -0,0 +1,29 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { ProgressBarProps as RemoteProgressBarElementProps } from '@mittwald/flow-react-components/ProgressBar';
+export type { ProgressBarProps as RemoteProgressBarElementProps } from '@mittwald/flow-react-components/ProgressBar';
+export declare class RemoteProgressBarElement extends FlowRemoteElement<RemoteProgressBarElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        formatOptions: {};
+        id: {};
+        isIndeterminate: {};
+        maxValue: {};
+        minValue: {};
+        showMaxValue: {};
+        size: {};
+        slot: {};
+        status: {};
+        value: {};
+    };
+    static get remoteEvents(): {};
+    static get remoteSlots(): string[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-progress-bar": InstanceType<typeof RemoteProgressBarElement>;
+    }
+}

package/dist/types/auto-generated/RemoteRadioButtonElement.d.ts

@@ -0,0 +1,34 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { RadioButtonProps as RemoteRadioButtonElementProps } from '@mittwald/flow-react-components/RadioGroup';
+export type { RadioButtonProps as RemoteRadioButtonElementProps } from '@mittwald/flow-react-components/RadioGroup';
+export declare class RemoteRadioButtonElement extends FlowRemoteElement<RemoteRadioButtonElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        autoFocus: {};
+        id: {};
+        inputRef: {};
+        isDisabled: {};
+        slot: {};
+        value: {};
+    };
+    static get remoteEvents(): {
+        blur: {};
+        focus: {};
+        focusChange: {};
+        hoverChange: {};
+        hoverEnd: {};
+        hoverStart: {};
+        keyDown: {};
+        keyUp: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-radio-button": InstanceType<typeof RemoteRadioButtonElement>;
+    }
+}

package/dist/types/auto-generated/RemoteRadioElement.d.ts

@@ -0,0 +1,34 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { RadioProps as RemoteRadioElementProps } from '@mittwald/flow-react-components/RadioGroup';
+export type { RadioProps as RemoteRadioElementProps } from '@mittwald/flow-react-components/RadioGroup';
+export declare class RemoteRadioElement extends FlowRemoteElement<RemoteRadioElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        autoFocus: {};
+        id: {};
+        inputRef: {};
+        isDisabled: {};
+        slot: {};
+        value: {};
+    };
+    static get remoteEvents(): {
+        blur: {};
+        focus: {};
+        focusChange: {};
+        hoverChange: {};
+        hoverEnd: {};
+        hoverStart: {};
+        keyDown: {};
+        keyUp: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-radio": InstanceType<typeof RemoteRadioElement>;
+    }
+}

package/dist/types/auto-generated/RemoteRadioGroupElement.d.ts

@@ -0,0 +1,40 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { RadioGroupProps as RemoteRadioGroupElementProps } from '@mittwald/flow-react-components/RadioGroup';
+export type { RadioGroupProps as RemoteRadioGroupElementProps } from '@mittwald/flow-react-components/RadioGroup';
+export declare class RemoteRadioGroupElement extends FlowRemoteElement<RemoteRadioGroupElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-errormessage": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        defaultValue: {};
+        id: {};
+        isDisabled: {};
+        isInvalid: {};
+        isReadOnly: {};
+        isRequired: {};
+        l: {};
+        m: {};
+        name: {};
+        orientation: {};
+        s: {};
+        slot: {};
+        validate: {};
+        validationBehavior: {};
+        value: {};
+    };
+    static get remoteEvents(): {
+        blur: {};
+        change: {};
+        focus: {};
+        focusChange: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-radio-group": InstanceType<typeof RemoteRadioGroupElement>;
+    }
+}

package/dist/types/auto-generated/RemoteReactHookFormFieldContentViewElement.d.ts

@@ -0,0 +1,16 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { ContentProps as RemoteReactHookFormFieldContentViewElementProps } from '@mittwald/flow-react-components/react-hook-form/Field/views';
+export type { ContentProps as RemoteReactHookFormFieldContentViewElementProps } from '@mittwald/flow-react-components/react-hook-form/Field/views';
+export declare class RemoteReactHookFormFieldContentViewElement extends FlowRemoteElement<RemoteReactHookFormFieldContentViewElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        errorMessage: {};
+    };
+    static get remoteEvents(): {};
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-react-hook-form-field-content-view": InstanceType<typeof RemoteReactHookFormFieldContentViewElement>;
+    }
+}

package/dist/types/auto-generated/RemoteSearchFieldElement.d.ts

@@ -0,0 +1,60 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { SearchFieldProps as RemoteSearchFieldElementProps } from '@mittwald/flow-react-components/SearchField';
+export type { SearchFieldProps as RemoteSearchFieldElementProps } from '@mittwald/flow-react-components/SearchField';
+export declare class RemoteSearchFieldElement extends FlowRemoteElement<RemoteSearchFieldElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-activedescendant": {};
+        "aria-autocomplete": {};
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-errormessage": {};
+        "aria-haspopup": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        autoComplete: {};
+        autoFocus: {};
+        defaultValue: {};
+        excludeFromTabOrder: {};
+        id: {};
+        inputMode: {};
+        isDisabled: {};
+        isInvalid: {};
+        isReadOnly: {};
+        isRequired: {};
+        maxLength: {};
+        minLength: {};
+        name: {};
+        pattern: {};
+        slot: {};
+        type: {};
+        validate: {};
+        validationBehavior: {};
+        value: {};
+    };
+    static get remoteEvents(): {
+        beforeInput: {};
+        blur: {};
+        change: {};
+        clear: {};
+        compositionEnd: {};
+        compositionStart: {};
+        compositionUpdate: {};
+        copy: {};
+        cut: {};
+        focus: {};
+        focusChange: {};
+        input: {};
+        keyDown: {};
+        keyUp: {};
+        paste: {};
+        select: {};
+        submit: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-search-field": InstanceType<typeof RemoteSearchFieldElement>;
+    }
+}

package/dist/types/auto-generated/RemoteSectionElement.d.ts

@@ -0,0 +1,290 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { SectionProps as RemoteSectionElementProps } from '@mittwald/flow-react-components/Section';
+export type { SectionProps as RemoteSectionElementProps } from '@mittwald/flow-react-components/Section';
+export declare class RemoteSectionElement extends FlowRemoteElement<RemoteSectionElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        about: {};
+        accessKey: {};
+        "aria-activedescendant": {};
+        "aria-atomic": {};
+        "aria-autocomplete": {};
+        "aria-braillelabel": {};
+        "aria-brailleroledescription": {};
+        "aria-busy": {};
+        "aria-checked": {};
+        "aria-colcount": {};
+        "aria-colindex": {};
+        "aria-colindextext": {};
+        "aria-colspan": {};
+        "aria-controls": {};
+        "aria-current": {};
+        "aria-describedby": {};
+        "aria-description": {};
+        "aria-details": {};
+        "aria-disabled": {};
+        "aria-dropeffect": {};
+        "aria-errormessage": {};
+        "aria-expanded": {};
+        "aria-flowto": {};
+        "aria-grabbed": {};
+        "aria-haspopup": {};
+        "aria-hidden": {};
+        "aria-invalid": {};
+        "aria-keyshortcuts": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        "aria-level": {};
+        "aria-live": {};
+        "aria-modal": {};
+        "aria-multiline": {};
+        "aria-multiselectable": {};
+        "aria-orientation": {};
+        "aria-owns": {};
+        "aria-placeholder": {};
+        "aria-posinset": {};
+        "aria-pressed": {};
+        "aria-readonly": {};
+        "aria-relevant": {};
+        "aria-required": {};
+        "aria-roledescription": {};
+        "aria-rowcount": {};
+        "aria-rowindex": {};
+        "aria-rowindextext": {};
+        "aria-rowspan": {};
+        "aria-selected": {};
+        "aria-setsize": {};
+        "aria-sort": {};
+        "aria-valuemax": {};
+        "aria-valuemin": {};
+        "aria-valuenow": {};
+        "aria-valuetext": {};
+        autoCapitalize: {};
+        autoCorrect: {};
+        autoFocus: {};
+        autoSave: {};
+        color: {};
+        content: {};
+        contentEditable: {};
+        contextMenu: {};
+        datatype: {};
+        defaultChecked: {};
+        defaultValue: {};
+        dir: {};
+        draggable: {};
+        enterKeyHint: {};
+        hidden: {};
+        hideSeparator: {};
+        id: {};
+        inert: {};
+        inlist: {};
+        inputMode: {};
+        is: {};
+        itemID: {};
+        itemProp: {};
+        itemRef: {};
+        itemScope: {};
+        itemType: {};
+        lang: {};
+        nonce: {};
+        popover: {};
+        popoverTarget: {};
+        popoverTargetAction: {};
+        prefix: {};
+        property: {};
+        radioGroup: {};
+        rel: {};
+        renderContextMenuSection: {};
+        resource: {};
+        results: {};
+        rev: {};
+        role: {};
+        security: {};
+        slot: {};
+        spellCheck: {};
+        suppressContentEditableWarning: {};
+        suppressHydrationWarning: {};
+        tabIndex: {};
+        title: {};
+        translate: {};
+        typeof: {};
+        unselectable: {};
+        vocab: {};
+    };
+    static get remoteEvents(): {
+        abort: {};
+        abortCapture: {};
+        animationEnd: {};
+        animationEndCapture: {};
+        animationIteration: {};
+        animationIterationCapture: {};
+        animationStart: {};
+        animationStartCapture: {};
+        auxClick: {};
+        auxClickCapture: {};
+        beforeInput: {};
+        beforeInputCapture: {};
+        beforeToggle: {};
+        blur: {};
+        blurCapture: {};
+        canPlay: {};
+        canPlayCapture: {};
+        canPlayThrough: {};
+        canPlayThroughCapture: {};
+        change: {};
+        changeCapture: {};
+        click: {};
+        clickCapture: {};
+        compositionEnd: {};
+        compositionEndCapture: {};
+        compositionStart: {};
+        compositionStartCapture: {};
+        compositionUpdate: {};
+        compositionUpdateCapture: {};
+        contextMenu: {};
+        contextMenuCapture: {};
+        copy: {};
+        copyCapture: {};
+        cut: {};
+        cutCapture: {};
+        doubleClick: {};
+        doubleClickCapture: {};
+        drag: {};
+        dragCapture: {};
+        dragEnd: {};
+        dragEndCapture: {};
+        dragEnter: {};
+        dragEnterCapture: {};
+        dragExit: {};
+        dragExitCapture: {};
+        dragLeave: {};
+        dragLeaveCapture: {};
+        dragOver: {};
+        dragOverCapture: {};
+        dragStart: {};
+        dragStartCapture: {};
+        drop: {};
+        dropCapture: {};
+        durationChange: {};
+        durationChangeCapture: {};
+        emptied: {};
+        emptiedCapture: {};
+        encrypted: {};
+        encryptedCapture: {};
+        ended: {};
+        endedCapture: {};
+        error: {};
+        errorCapture: {};
+        focus: {};
+        focusCapture: {};
+        gotPointerCapture: {};
+        gotPointerCaptureCapture: {};
+        input: {};
+        inputCapture: {};
+        invalid: {};
+        invalidCapture: {};
+        keyDown: {};
+        keyDownCapture: {};
+        keyPress: {};
+        keyPressCapture: {};
+        keyUp: {};
+        keyUpCapture: {};
+        load: {};
+        loadCapture: {};
+        loadStart: {};
+        loadStartCapture: {};
+        loadedData: {};
+        loadedDataCapture: {};
+        loadedMetadata: {};
+        loadedMetadataCapture: {};
+        lostPointerCapture: {};
+        lostPointerCaptureCapture: {};
+        mouseDown: {};
+        mouseDownCapture: {};
+        mouseEnter: {};
+        mouseLeave: {};
+        mouseMove: {};
+        mouseMoveCapture: {};
+        mouseOut: {};
+        mouseOutCapture: {};
+        mouseOver: {};
+        mouseOverCapture: {};
+        mouseUp: {};
+        mouseUpCapture: {};
+        paste: {};
+        pasteCapture: {};
+        pause: {};
+        pauseCapture: {};
+        play: {};
+        playCapture: {};
+        playing: {};
+        playingCapture: {};
+        pointerCancel: {};
+        pointerCancelCapture: {};
+        pointerDown: {};
+        pointerDownCapture: {};
+        pointerEnter: {};
+        pointerLeave: {};
+        pointerMove: {};
+        pointerMoveCapture: {};
+        pointerOut: {};
+        pointerOutCapture: {};
+        pointerOver: {};
+        pointerOverCapture: {};
+        pointerUp: {};
+        pointerUpCapture: {};
+        progress: {};
+        progressCapture: {};
+        rateChange: {};
+        rateChangeCapture: {};
+        reset: {};
+        resetCapture: {};
+        resize: {};
+        resizeCapture: {};
+        scroll: {};
+        scrollCapture: {};
+        seeked: {};
+        seekedCapture: {};
+        seeking: {};
+        seekingCapture: {};
+        select: {};
+        selectCapture: {};
+        stalled: {};
+        stalledCapture: {};
+        submit: {};
+        submitCapture: {};
+        suspend: {};
+        suspendCapture: {};
+        timeUpdate: {};
+        timeUpdateCapture: {};
+        toggle: {};
+        touchCancel: {};
+        touchCancelCapture: {};
+        touchEnd: {};
+        touchEndCapture: {};
+        touchMove: {};
+        touchMoveCapture: {};
+        touchStart: {};
+        touchStartCapture: {};
+        transitionCancel: {};
+        transitionCancelCapture: {};
+        transitionEnd: {};
+        transitionEndCapture: {};
+        transitionRun: {};
+        transitionRunCapture: {};
+        transitionStart: {};
+        transitionStartCapture: {};
+        volumeChange: {};
+        volumeChangeCapture: {};
+        waiting: {};
+        waitingCapture: {};
+        wheel: {};
+        wheelCapture: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-section": InstanceType<typeof RemoteSectionElement>;
+    }
+}

package/dist/types/auto-generated/RemoteSegmentElement.d.ts

@@ -0,0 +1,34 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { SegmentProps as RemoteSegmentElementProps } from '@mittwald/flow-react-components/SegmentedControl';
+export type { SegmentProps as RemoteSegmentElementProps } from '@mittwald/flow-react-components/SegmentedControl';
+export declare class RemoteSegmentElement extends FlowRemoteElement<RemoteSegmentElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        autoFocus: {};
+        id: {};
+        inputRef: {};
+        isDisabled: {};
+        slot: {};
+        value: {};
+    };
+    static get remoteEvents(): {
+        blur: {};
+        focus: {};
+        focusChange: {};
+        hoverChange: {};
+        hoverEnd: {};
+        hoverStart: {};
+        keyDown: {};
+        keyUp: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-segment": InstanceType<typeof RemoteSegmentElement>;
+    }
+}

package/dist/types/auto-generated/RemoteSegmentedControlElement.d.ts

@@ -0,0 +1,38 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { SegmentedControlProps as RemoteSegmentedControlElementProps } from '@mittwald/flow-react-components/SegmentedControl';
+export type { SegmentedControlProps as RemoteSegmentedControlElementProps } from '@mittwald/flow-react-components/SegmentedControl';
+export declare class RemoteSegmentedControlElement extends FlowRemoteElement<RemoteSegmentedControlElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-errormessage": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        containerBreakpointSize: {};
+        defaultValue: {};
+        id: {};
+        isDisabled: {};
+        isInvalid: {};
+        isReadOnly: {};
+        isRequired: {};
+        name: {};
+        orientation: {};
+        slot: {};
+        validate: {};
+        validationBehavior: {};
+        value: {};
+    };
+    static get remoteEvents(): {
+        blur: {};
+        change: {};
+        focus: {};
+        focusChange: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-segmented-control": InstanceType<typeof RemoteSegmentedControlElement>;
+    }
+}

package/dist/types/auto-generated/RemoteSelectElement.d.ts

@@ -0,0 +1,46 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { SelectProps as RemoteSelectElementProps } from '@mittwald/flow-react-components/Select';
+export type { SelectProps as RemoteSelectElementProps } from '@mittwald/flow-react-components/Select';
+export declare class RemoteSelectElement extends FlowRemoteElement<RemoteSelectElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        autoComplete: {};
+        autoFocus: {};
+        controller: {};
+        defaultOpen: {};
+        defaultSelectedKey: {};
+        disabledKeys: {};
+        excludeFromTabOrder: {};
+        id: {};
+        isDisabled: {};
+        isInvalid: {};
+        isOpen: {};
+        isRequired: {};
+        name: {};
+        placeholder: {};
+        selectedKey: {};
+        slot: {};
+        validate: {};
+        validationBehavior: {};
+    };
+    static get remoteEvents(): {
+        blur: {};
+        change: {};
+        focus: {};
+        focusChange: {};
+        keyDown: {};
+        keyUp: {};
+        openChange: {};
+        selectionChange: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-select": InstanceType<typeof RemoteSelectElement>;
+    }
+}

package/dist/types/auto-generated/RemoteSeparatorElement.d.ts

@@ -0,0 +1,22 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { SeparatorProps as RemoteSeparatorElementProps } from '@mittwald/flow-react-components/Separator';
+export type { SeparatorProps as RemoteSeparatorElementProps } from '@mittwald/flow-react-components/Separator';
+export declare class RemoteSeparatorElement extends FlowRemoteElement<RemoteSeparatorElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        elementType: {};
+        id: {};
+        slot: {};
+    };
+    static get remoteEvents(): {};
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-separator": InstanceType<typeof RemoteSeparatorElement>;
+    }
+}