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

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

@@ -0,0 +1,496 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { AlertIconProps as RemoteAlertIconElementProps } from '@mittwald/flow-react-components/AlertIcon';
+export type { AlertIconProps as RemoteAlertIconElementProps } from '@mittwald/flow-react-components/AlertIcon';
+export declare class RemoteAlertIconElement extends FlowRemoteElement<RemoteAlertIconElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        accentHeight: {};
+        accumulate: {};
+        additive: {};
+        alignmentBaseline: {};
+        allowReorder: {};
+        alphabetic: {};
+        amplitude: {};
+        arabicForm: {};
+        "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": {};
+        ascent: {};
+        attributeName: {};
+        attributeType: {};
+        autoReverse: {};
+        azimuth: {};
+        baseFrequency: {};
+        baseProfile: {};
+        baselineShift: {};
+        bbox: {};
+        begin: {};
+        bias: {};
+        by: {};
+        calcMode: {};
+        capHeight: {};
+        clip: {};
+        clipPath: {};
+        clipPathUnits: {};
+        clipRule: {};
+        color: {};
+        colorInterpolation: {};
+        colorInterpolationFilters: {};
+        colorProfile: {};
+        colorRendering: {};
+        contentScriptType: {};
+        contentStyleType: {};
+        crossOrigin: {};
+        cursor: {};
+        cx: {};
+        cy: {};
+        d: {};
+        decelerate: {};
+        descent: {};
+        diffuseConstant: {};
+        direction: {};
+        display: {};
+        divisor: {};
+        dominantBaseline: {};
+        dur: {};
+        dx: {};
+        dy: {};
+        edgeMode: {};
+        elevation: {};
+        enableBackground: {};
+        end: {};
+        exponent: {};
+        externalResourcesRequired: {};
+        fill: {};
+        fillOpacity: {};
+        fillRule: {};
+        filter: {};
+        filterRes: {};
+        filterUnits: {};
+        floodColor: {};
+        floodOpacity: {};
+        focusable: {};
+        fontFamily: {};
+        fontSize: {};
+        fontSizeAdjust: {};
+        fontStretch: {};
+        fontStyle: {};
+        fontVariant: {};
+        fontWeight: {};
+        format: {};
+        fr: {};
+        from: {};
+        fx: {};
+        fy: {};
+        g1: {};
+        g2: {};
+        glyphName: {};
+        glyphOrientationHorizontal: {};
+        glyphOrientationVertical: {};
+        glyphRef: {};
+        gradientTransform: {};
+        gradientUnits: {};
+        hanging: {};
+        height: {};
+        horizAdvX: {};
+        horizOriginX: {};
+        href: {};
+        id: {};
+        ideographic: {};
+        imageRendering: {};
+        in: {};
+        in2: {};
+        intercept: {};
+        k: {};
+        k1: {};
+        k2: {};
+        k3: {};
+        k4: {};
+        kernelMatrix: {};
+        kernelUnitLength: {};
+        kerning: {};
+        keyPoints: {};
+        keySplines: {};
+        keyTimes: {};
+        lang: {};
+        lengthAdjust: {};
+        letterSpacing: {};
+        lightingColor: {};
+        limitingConeAngle: {};
+        local: {};
+        markerEnd: {};
+        markerHeight: {};
+        markerMid: {};
+        markerStart: {};
+        markerUnits: {};
+        markerWidth: {};
+        mask: {};
+        maskContentUnits: {};
+        maskUnits: {};
+        mathematical: {};
+        max: {};
+        media: {};
+        method: {};
+        min: {};
+        mode: {};
+        numOctaves: {};
+        offset: {};
+        opacity: {};
+        operator: {};
+        order: {};
+        orient: {};
+        orientation: {};
+        origin: {};
+        overflow: {};
+        overlinePosition: {};
+        overlineThickness: {};
+        paintOrder: {};
+        panose1: {};
+        path: {};
+        pathLength: {};
+        patternContentUnits: {};
+        patternTransform: {};
+        patternUnits: {};
+        pointerEvents: {};
+        points: {};
+        pointsAtX: {};
+        pointsAtY: {};
+        pointsAtZ: {};
+        preserveAlpha: {};
+        preserveAspectRatio: {};
+        primitiveUnits: {};
+        r: {};
+        radius: {};
+        refX: {};
+        refY: {};
+        renderingIntent: {};
+        repeatCount: {};
+        repeatDur: {};
+        requiredExtensions: {};
+        requiredFeatures: {};
+        restart: {};
+        result: {};
+        role: {};
+        rotate: {};
+        rx: {};
+        ry: {};
+        scale: {};
+        seed: {};
+        shapeRendering: {};
+        size: {};
+        slope: {};
+        spacing: {};
+        specularConstant: {};
+        specularExponent: {};
+        speed: {};
+        spreadMethod: {};
+        startOffset: {};
+        status: {};
+        stdDeviation: {};
+        stemh: {};
+        stemv: {};
+        stitchTiles: {};
+        stopColor: {};
+        stopOpacity: {};
+        strikethroughPosition: {};
+        strikethroughThickness: {};
+        string: {};
+        stroke: {};
+        strokeDasharray: {};
+        strokeDashoffset: {};
+        strokeLinecap: {};
+        strokeLinejoin: {};
+        strokeMiterlimit: {};
+        strokeOpacity: {};
+        strokeWidth: {};
+        suppressHydrationWarning: {};
+        surfaceScale: {};
+        systemLanguage: {};
+        tabIndex: {};
+        tableValues: {};
+        target: {};
+        targetX: {};
+        targetY: {};
+        textAnchor: {};
+        textDecoration: {};
+        textLength: {};
+        textRendering: {};
+        to: {};
+        transform: {};
+        type: {};
+        u1: {};
+        u2: {};
+        underlinePosition: {};
+        underlineThickness: {};
+        unicode: {};
+        unicodeBidi: {};
+        unicodeRange: {};
+        unitsPerEm: {};
+        vAlphabetic: {};
+        vHanging: {};
+        vIdeographic: {};
+        vMathematical: {};
+        values: {};
+        vectorEffect: {};
+        version: {};
+        vertAdvY: {};
+        vertOriginX: {};
+        vertOriginY: {};
+        viewBox: {};
+        viewTarget: {};
+        visibility: {};
+        width: {};
+        widths: {};
+        wordSpacing: {};
+        writingMode: {};
+        x: {};
+        x1: {};
+        x2: {};
+        xChannelSelector: {};
+        xHeight: {};
+        xlinkActuate: {};
+        xlinkArcrole: {};
+        xlinkHref: {};
+        xlinkRole: {};
+        xlinkShow: {};
+        xlinkTitle: {};
+        xlinkType: {};
+        xmlBase: {};
+        xmlLang: {};
+        xmlSpace: {};
+        xmlns: {};
+        xmlnsXlink: {};
+        y: {};
+        y1: {};
+        y2: {};
+        yChannelSelector: {};
+        z: {};
+        zoomAndPan: {};
+    };
+    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-alert-icon": InstanceType<typeof RemoteAlertIconElement>;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { AlignProps as RemoteAlignElementProps } from '@mittwald/flow-react-components/Align';
+export type { AlignProps as RemoteAlignElementProps } from '@mittwald/flow-react-components/Align';
+export declare class RemoteAlignElement extends FlowRemoteElement<RemoteAlignElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {};
+    static get remoteEvents(): {};
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-align": InstanceType<typeof RemoteAlignElement>;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { AvatarProps as RemoteAvatarElementProps } from '@mittwald/flow-react-components/Avatar';
+export type { AvatarProps as RemoteAvatarElementProps } from '@mittwald/flow-react-components/Avatar';
+export declare class RemoteAvatarElement extends FlowRemoteElement<RemoteAvatarElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        color: {};
+        size: {};
+    };
+    static get remoteEvents(): {};
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-avatar": InstanceType<typeof RemoteAvatarElement>;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { BadgeProps as RemoteBadgeElementProps } from '@mittwald/flow-react-components/Badge';
+export type { BadgeProps as RemoteBadgeElementProps } from '@mittwald/flow-react-components/Badge';
+export declare class RemoteBadgeElement extends FlowRemoteElement<RemoteBadgeElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        color: {};
+        isDisabled: {};
+    };
+    static get remoteEvents(): {
+        close: {};
+        press: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-badge": InstanceType<typeof RemoteBadgeElement>;
+    }
+}

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

@@ -0,0 +1,27 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { BreadcrumbProps as RemoteBreadcrumbElementProps } from '@mittwald/flow-react-components/Breadcrumb';
+export type { BreadcrumbProps as RemoteBreadcrumbElementProps } from '@mittwald/flow-react-components/Breadcrumb';
+export declare class RemoteBreadcrumbElement extends FlowRemoteElement<RemoteBreadcrumbElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        color: {};
+        dependencies: {};
+        id: {};
+        isDisabled: {};
+        items: {};
+        slot: {};
+    };
+    static get remoteEvents(): {
+        action: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-breadcrumb": InstanceType<typeof RemoteBreadcrumbElement>;
+    }
+}

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

@@ -0,0 +1,61 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { ButtonProps as RemoteButtonElementProps } from '@mittwald/flow-react-components/Button';
+export type { ButtonProps as RemoteButtonElementProps } from '@mittwald/flow-react-components/Button';
+export declare class RemoteButtonElement extends FlowRemoteElement<RemoteButtonElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-controls": {};
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-disabled": {};
+        "aria-expanded": {};
+        "aria-haspopup": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        "aria-pressed": {};
+        ariaSlot: {};
+        autoFocus: {};
+        color: {};
+        excludeFromTabOrder: {};
+        form: {};
+        formAction: {};
+        formEncType: {};
+        formMethod: {};
+        formNoValidate: {};
+        formTarget: {};
+        id: {};
+        isDisabled: {};
+        isFailed: {};
+        isPending: {};
+        isSucceeded: {};
+        name: {};
+        preventFocusOnPress: {};
+        size: {};
+        slot: {};
+        type: {};
+        unstyled: {};
+        value: {};
+        variant: {};
+    };
+    static get remoteEvents(): {
+        blur: {};
+        focus: {};
+        focusChange: {};
+        hoverChange: {};
+        hoverEnd: {};
+        hoverStart: {};
+        keyDown: {};
+        keyUp: {};
+        press: {};
+        pressChange: {};
+        pressEnd: {};
+        pressStart: {};
+        pressUp: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-button": InstanceType<typeof RemoteButtonElement>;
+    }
+}

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

@@ -0,0 +1,47 @@
+import { FlowRemoteElement } from '../lib/FlowRemoteElement';
+import { CheckboxButtonProps as RemoteCheckboxButtonElementProps } from '@mittwald/flow-react-components/CheckboxButton';
+export type { CheckboxButtonProps as RemoteCheckboxButtonElementProps } from '@mittwald/flow-react-components/CheckboxButton';
+export declare class RemoteCheckboxButtonElement extends FlowRemoteElement<RemoteCheckboxButtonElementProps> {
+    static get remoteAttributes(): never[];
+    static get remoteProperties(): {
+        "aria-controls": {};
+        "aria-describedby": {};
+        "aria-details": {};
+        "aria-errormessage": {};
+        "aria-label": {};
+        "aria-labelledby": {};
+        autoFocus: {};
+        defaultSelected: {};
+        excludeFromTabOrder: {};
+        id: {};
+        inputRef: {};
+        isDisabled: {};
+        isIndeterminate: {};
+        isInvalid: {};
+        isReadOnly: {};
+        isRequired: {};
+        isSelected: {};
+        name: {};
+        slot: {};
+        validate: {};
+        validationBehavior: {};
+        value: {};
+    };
+    static get remoteEvents(): {
+        blur: {};
+        change: {};
+        focus: {};
+        focusChange: {};
+        hoverChange: {};
+        hoverEnd: {};
+        hoverStart: {};
+        keyDown: {};
+        keyUp: {};
+    };
+    static get remoteSlots(): never[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "flr-checkbox-button": InstanceType<typeof RemoteCheckboxButtonElement>;
+    }
+}