@membranehq/react 0.1.0

package/dist/types/components/DropdownUI/index.d.ts

@@ -0,0 +1,43 @@
+import { ItemHint } from './ItemHint';
+import { ItemIcon } from './ItemIcon';
+import { ItemNestingIndicator } from './ItemNestingIndicator';
+import { ItemTitle } from './ItemTitle';
+export declare const DropdownUI: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>> & {
+    Content: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;
+    Search: import("react").ForwardRefExoticComponent<{
+        value?: string;
+        onChange?: (value: string) => void;
+        autoFocus?: boolean;
+        placeholder?: HTMLInputElement["placeholder"];
+    } & Omit<import("react").HTMLAttributes<HTMLDivElement>, "onChange"> & import("react").RefAttributes<HTMLInputElement>>;
+    SearchDivider: () => import("react/jsx-runtime").JSX.Element;
+    ClearSearchButton: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLButtonElement> & import("react").RefAttributes<HTMLButtonElement>>;
+    Panel: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;
+    List: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<{
+        className?: string;
+        current?: boolean;
+    } & import("react").HTMLAttributes<HTMLDivElement> & {
+        children?: import("react").ReactNode | undefined;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+    ListHeader: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLSpanElement> & import("react").RefAttributes<HTMLSpanElement>>;
+    BackButton: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLButtonElement> & {
+        current?: boolean;
+    } & import("react").RefAttributes<HTMLButtonElement>>;
+    NoOptionsHeading: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLDivElement>, "children"> & {
+        text?: string;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+    ErrorHeading: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLDivElement>, "children"> & {
+        text?: string;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+    InfoHeading: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLDivElement>, "children"> & {
+        text?: string;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+    LoadingItem: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLDivElement>, "children"> & {
+        delay?: number;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+    ItemIcon: typeof ItemIcon;
+    ItemTitle: typeof ItemTitle;
+    ItemNestingIndicator: typeof ItemNestingIndicator;
+    ItemHint: typeof ItemHint;
+};

package/dist/types/components/DropdownUI/item-aria-context.d.ts

@@ -0,0 +1,6 @@
+export declare const DropdownItemAriaContextProvider: import("react").Provider<{
+    titleId?: string;
+}>;
+export declare const useDropdownItemAriaContext: () => {
+    titleId?: string;
+};

package/dist/types/components/DropdownUI/sva-recipe.d.ts

@@ -0,0 +1 @@
+export declare const scrollShadow: import("../../styled-system/types").RecipeRuntimeFn<import("../../styled-system/types").RecipeVariantRecord>;

package/dist/types/components/DropdownUI/utils.d.ts

@@ -0,0 +1,2 @@
+import { MouseEventHandler } from 'react';
+export declare const preventFocusShift: MouseEventHandler;

package/dist/types/components/FloatingPortalBoundary/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export declare function FloatingPortalBoundary({ children, id, ...props }: {
+    children: React.ReactElement;
+    id?: string;
+} & React.HTMLAttributes<HTMLElement>): import("react/jsx-runtime").JSX.Element;
+export declare function BoundedPortal({ children, usePortal, }: {
+    children: React.ReactNode;
+    usePortal?: boolean | HTMLElement;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/IntegrationElements/DataSource/DataCollectionSelect.d.ts

@@ -0,0 +1,6 @@
+import { DataSchema, DataSourceUnitConfig } from '@membranehq/sdk';
+export declare function DataCollectionSelect({ value, onChange, variablesSchema, }: {
+    value: DataSourceUnitConfig | undefined;
+    onChange: (value: Partial<DataSourceUnitConfig>) => void;
+    variablesSchema?: DataSchema;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/IntegrationElements/DataSource/UdmSelect.d.ts

@@ -0,0 +1,2 @@
+import { DataSourceConfigProps } from './types';
+export declare function UdmSelect({ value, onChange }: DataSourceConfigProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/IntegrationElements/DataSource/index.d.ts

@@ -0,0 +1,7 @@
+import { DataSourceUnitConfig } from '@membranehq/sdk';
+import { DataSourceConfigProps } from './types';
+export declare function DataSourceConfig(props: DataSourceConfigProps): import("react/jsx-runtime").JSX.Element;
+export declare function DataSourceConfigureEvents({ value, onChange, }: {
+    value: DataSourceUnitConfig | undefined;
+    onChange: (value: DataSourceUnitConfig) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/IntegrationElements/DataSource/types.d.ts

@@ -0,0 +1,7 @@
+import { DataSchema, DataSourceUnitConfig } from '@membranehq/sdk';
+export interface DataSourceConfigProps {
+    value: DataSourceUnitConfig | undefined;
+    onChange: (value: any) => void;
+    configureEvents?: boolean;
+    variablesSchema?: DataSchema;
+}

package/dist/types/components/IntegrationElements/index.d.ts

@@ -0,0 +1,4 @@
+export * from './integration-element-context';
+export * from './DataSource';
+export * from './DataSource/UdmSelect';
+export * from './DataSource/DataCollectionSelect';

package/dist/types/components/IntegrationElements/integration-element-context.d.ts

@@ -0,0 +1,11 @@
+import { PropsWithChildren } from 'react';
+import { IntegrationElementLevel } from '@membranehq/sdk';
+export declare function useIntegrationElementContext(): {
+    level: IntegrationElementLevel;
+    integrationId?: string;
+    connectionId?: string;
+};
+export declare const IntegrationElementProvider: ({ children, integrationId: integrationIdfromParams, connectionId: connectionIdFromParams, }: PropsWithChildren<{
+    integrationId?: string;
+    connectionId?: string;
+}>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Integrations/IntegrationAvatar/index.d.ts

@@ -0,0 +1,6 @@
+import { Integration } from '@membranehq/sdk';
+type HTMLDivProps = React.HTMLAttributes<HTMLDivElement>;
+export declare const IntegrationAvatar: React.FC<{
+    integration: Integration;
+} & HTMLDivProps>;
+export {};

package/dist/types/components/Integrations/IntegrationItem/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { Integration } from '@membranehq/sdk';
+import { StrictAsChild } from '../../../helpers/types';
+type HTMLButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+export declare const IntegrationItem: React.ForwardRefExoticComponent<({
+    integration: Integration;
+} & (HTMLButtonProps & StrictAsChild<HTMLButtonElement>)) & React.RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/types/components/Integrations/IntegrationItemSkeleton.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+type HTMLDivProps = React.HTMLAttributes<HTMLDivElement>;
+export declare const IntegrationItemSkeleton: React.ForwardRefExoticComponent<Omit<HTMLDivProps, "children"> & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/components/Integrations/index.d.ts

@@ -0,0 +1,3 @@
+export * from './IntegrationAvatar';
+export * from './IntegrationItem';
+export * from './IntegrationItemSkeleton';

package/dist/types/components/Notification/index.d.ts

@@ -0,0 +1,16 @@
+import { PropsWithChildren } from 'react';
+import { SvgIconType } from '../../components/SvgIcon/svg-icon-type';
+export type NotificationType = 'info' | 'warning' | 'error' | 'default';
+type NotificationMode = 'block' | 'icon';
+type NotificationSize = 'sm' | 'md';
+type GenericNotificationProps = {
+    type?: NotificationType;
+    size?: NotificationSize;
+    icon?: SvgIconType;
+    className?: string;
+};
+type NotificationProps = GenericNotificationProps & {
+    mode?: NotificationMode;
+};
+export declare function Notification({ mode, children, ...props }: PropsWithChildren<NotificationProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Popover/index.d.ts

@@ -0,0 +1,25 @@
+import React, { PropsWithChildren } from 'react';
+import { Popover } from '../../ui-kit/popover';
+import { PopperRefElementType } from '../ComboBox/shared';
+export type PopperProps = PropsWithChildren<{
+    refElement?: PopperRefElementType;
+    isOpen?: boolean;
+    onClick?: () => void;
+    className?: string;
+    placement?: NonNullable<Popover.RootProps['positioning']>['placement'];
+    triggerNode?: React.ReactNode;
+    offset?: [number, number];
+    onClickOutside?: () => void;
+}>;
+export declare const DefaultPopper: React.ForwardRefExoticComponent<{
+    refElement?: PopperRefElementType;
+    isOpen?: boolean;
+    onClick?: () => void;
+    className?: string;
+    placement?: NonNullable<Popover.RootProps["positioning"]>["placement"];
+    triggerNode?: React.ReactNode;
+    offset?: [number, number];
+    onClickOutside?: () => void;
+} & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/Portal/index.d.ts

@@ -0,0 +1,7 @@
+import { PropsWithChildren, RefObject } from 'react';
+type PortalNodeType = null | string | Element | RefObject<Element> | GetPortalNodeFnType;
+type GetPortalNodeFnType = (...args: any) => Element | RefObject<Element>;
+export declare function Portal({ node, children }: PropsWithChildren<{
+    node?: PortalNodeType;
+}>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Radio/Radio.stories.d.ts

@@ -0,0 +1,9 @@
+import { Radiobutton } from './index';
+import type { Meta, StoryObj } from '@storybook/react';
+declare const meta: Meta<typeof Radiobutton>;
+export default meta;
+type Story = StoryObj<typeof Radiobutton>;
+export declare const Default: Story;
+export declare const Checked: Story;
+export declare const Disabled: Story;
+export declare const DisabledChecked: Story;

package/dist/types/components/Radio/index.d.ts

@@ -0,0 +1,6 @@
+import { InputHTMLAttributes } from 'react';
+export interface RadiobuttonProps extends InputHTMLAttributes<HTMLInputElement> {
+    className?: string;
+    inline?: boolean;
+}
+export declare const Radiobutton: import("react").ForwardRefExoticComponent<RadiobuttonProps & import("react").RefAttributes<HTMLInputElement>>;

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

@@ -0,0 +1,9 @@
+type BaseInputProps = React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+interface SimpleInputProps extends Omit<BaseInputProps, 'onChange'> {
+    label?: string;
+    description?: string;
+    value: string | undefined;
+    onChange: (value: string | undefined) => void;
+}
+export declare function SimpleInput({ label, value, description, onChange, className, ...props }: SimpleInputProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/SimpleInput/SimpleTextarea.d.ts

@@ -0,0 +1,12 @@
+import { TextareaWithAutoHeightProps, TextareaWithoutAutoHeightProps, TextareaWithUndefinedAutoHeightProps } from '../Textarea';
+type SimpleTextareaGenericProps = {
+    label?: string;
+    value: string | undefined;
+    onChange: (value: string | undefined) => void;
+};
+type SimpleTextareaWithUndefinedAutoHeightProps = SimpleTextareaGenericProps & Omit<TextareaWithUndefinedAutoHeightProps, 'onChange' | 'variant'>;
+type SimpleTextareaWithAutoHeightProps = SimpleTextareaGenericProps & Omit<TextareaWithAutoHeightProps, 'onChange' | 'variant'>;
+type SimpleTextareaWithoutAutoHeightProps = SimpleTextareaGenericProps & Omit<TextareaWithoutAutoHeightProps, 'onChange' | 'variant'>;
+type SimpleTextareaProps = SimpleTextareaWithUndefinedAutoHeightProps | SimpleTextareaWithAutoHeightProps | SimpleTextareaWithoutAutoHeightProps;
+export declare function SimpleTextarea({ label, value, onChange, ...props }: SimpleTextareaProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/SimpleInput/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SimpleInput';
+export * from './SimpleTextarea';

package/dist/types/components/SimpleInput/recipe.d.ts

@@ -0,0 +1,11 @@
+export declare const simpleInputRecipe: import("../../styled-system/types").SlotRecipeRuntimeFn<"input" | "textarea" | "title" | "cell" | "row", {
+    disabled: {
+        true: {
+            row: {
+                bg: "neutral.1";
+                color: "neutral.9";
+            };
+        };
+        false: {};
+    };
+}>;

package/dist/types/components/SvgIcon/BasicEntities.d.ts

@@ -0,0 +1,35 @@
+export declare function SvgIconUnifiedInterfaces({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconUnifiedInterface({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconApp({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconFieldMappings({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const SvgIconFieldMapping: typeof SvgIconFieldMappings;
+export declare function SvgIconFlows({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const SvgIconFlow: typeof SvgIconFlows;
+export declare function SvgIconDataSources({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconObjectLinks({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconObjectLink({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconDataSchema({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconDataSchemas({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconAppEventSubscriptions({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/SvgIcon/index.d.ts

@@ -0,0 +1,8 @@
+import { SVGProps } from 'react';
+import { SvgIconType } from './svg-icon-type';
+type CustomSvgIconProps = SVGProps<SVGSVGElement>;
+type SvgIconProps = Omit<CustomSvgIconProps, 'type'> & {
+    type: SvgIconType;
+};
+export declare function SvgIcon({ type, ...props }: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/SvgIcon/svg-icon-type.d.ts

@@ -0,0 +1,85 @@
+export declare enum SvgIconType {
+    Add = "Add",
+    AlertCircle = "AlertCircle",
+    AlertOctagon = "AlertOctagon",
+    AlertTriangle = "AlertTriangle",
+    Array = "Array",
+    ArrowRight = "ArrowRight",
+    Braces = "Braces",
+    Cancel = "Cancel",
+    Check = "Check",
+    ChevronDown = "ChevronDown",
+    ChevronLeft = "ChevronLeft",
+    ChevronRight = "ChevronRight",
+    ChevronUp = "ChevronUp",
+    Close = "Close",
+    Copy = "Copy",
+    DefaultWorkspaceIcon = "DefaultWorkspaceIcon",
+    Delete = "Delete",
+    Edit = "Edit",
+    Function = "Function",
+    InfoCircle = "InfoCircle",
+    Link = "Link",
+    ListOption = "ListOption",
+    Loader = "Loader",
+    Lookup = "Lookup",
+    PlayerPlay = "PlayerPlay",
+    PlayerPlayFilled = "PlayerPlayFilled",
+    QuestionMark = "QuestionMark",
+    Refresh = "Refresh",
+    Reset = "Reset",
+    SchemaType_array = "SchemaTypeArray",
+    SchemaType_boolean = "SchemaTypeBoolean",
+    SchemaType_connection = "SchemaTypeConnection",
+    SchemaType_integer = "SchemaTypeInteger",
+    SchemaType_number = "SchemaTypeNumber",
+    SchemaType_object = "SchemaTypeObject",
+    SchemaType_request = "SchemaTypeRequest",
+    SchemaType_string = "SchemaTypeString",
+    Search = "Search",
+    Settings = "Settings",
+    ThreeDots = "ThreeDots",
+    Unlink = "Unlink",
+    ValueMapping = "ValueMapping",
+    Variable = "Variable",
+    ZoomCancel = "ZoomCancel",
+    ActionEntity = "Action",
+    ActionsEntity = "Actions",
+    TemplatesEntity = "Templates",
+    TemplateEntity = "Template",
+    AppsEntity = "Apps",
+    AppEntity = "App",
+    ApisEntity = "Apis",
+    ApiEntity = "Api",
+    FieldMappingsEntity = "FieldMappings",
+    FieldMappingEntity = "FieldMapping",
+    FlowsEntity = "Flows",
+    FlowEntity = "Flow",
+    DataSourcesEntity = "DataSources",
+    DataSourceEntity = "DataSource",
+    ObjectLinksEntity = "ObjectLinks",
+    ObjectLinkEntity = "ObjectLink",
+    UsersEntity = "UsersEntity",
+    UserEntity = "UserEntity",
+    DataSchemasEntity = "DataSchemas",
+    DataSchemaEntity = "DataSchema",
+    DataLinkEntity = "DataLink",
+    AppEventSubscriptionsEntity = "AppEventSubscriptions",
+    AppEventSubscriptionEntity = "AppEventSubscription",
+    CustomFieldsEntity = "CustomFields",
+    MonitoringEntity = "Monitoring",
+    LogEntity = "LogEntity",
+    UDMEntity = "UDMEntity",
+    UdmActivities = "UdmActivities",
+    UdmCampains = "UdmCampains",
+    UdmCompanies = "UdmCompanies",
+    UdmContacts = "UdmContacts",
+    UdmDeals = "UdmDeals",
+    UdmDealProducts = "UdmDealProducts",
+    UdmProducts = "UdmProducts",
+    UdmUsers = "UdmUsers",
+    UdmMeetings = "UdmMeetings",
+    UdmTasks = "UdmTasks",
+    UdmNotes = "UdmNotes",
+    UdmEmails = "UdmEmails"
+}

package/dist/types/components/Tag/Components.d.ts

@@ -0,0 +1,12 @@
+import { ImgHTMLAttributes } from 'react';
+import { SvgIconType } from '../../components/SvgIcon/svg-icon-type';
+export declare function TagSvgIcon({ type, className, ...props }: {
+    type: SvgIconType;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function TagImage({ className, alt, ...props }: ImgHTMLAttributes<HTMLImageElement>): import("react/jsx-runtime").JSX.Element;
+export declare function TagConfigButton({ error, icon, onClick }: {
+    error?: boolean | undefined;
+    icon?: SvgIconType | undefined;
+    onClick: any;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,23 @@
+import { ComponentProps, PropsWithChildren } from 'react';
+import { TagConfigButton, TagImage, TagSvgIcon } from './Components';
+export interface ITagProps extends ComponentProps<any> {
+    truncate?: boolean;
+    inactive?: boolean;
+    disabled?: boolean;
+}
+export interface IBasicTagProps extends ITagProps {
+    tooltip?: string;
+}
+export declare const GenericTag: import("react").ForwardRefExoticComponent<Omit<ITagProps, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+export declare const Tag: import("react").ForwardRefExoticComponent<Omit<IBasicTagProps, "ref"> & import("react").RefAttributes<HTMLSpanElement>> & {
+    SvgIcon: typeof TagSvgIcon;
+    Image: typeof TagImage;
+    ConfigButton: typeof TagConfigButton;
+    Lookup: typeof TagLookup;
+};
+interface ILookupTagProps extends ITagProps {
+    onConfigClick: () => void;
+    configError?: boolean;
+}
+declare function TagLookup({ children, disabled, onConfigClick, configError }: PropsWithChildren<ILookupTagProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Tag/TagPlaceholder.d.ts

@@ -0,0 +1,5 @@
+import { HTMLAttributes } from 'react';
+interface ITagPlaceholderProps extends HTMLAttributes<HTMLSpanElement> {
+}
+export declare const TagPlaceholder: import("react").ForwardRefExoticComponent<ITagPlaceholderProps & import("react").RefAttributes<HTMLSpanElement>>;
+export {};

package/dist/types/components/Tag/index.d.ts

@@ -0,0 +1,4 @@
+import { Tag } from './Tag';
+export * from './Tag';
+export * from './TagPlaceholder';
+export default Tag;

package/dist/types/components/Textarea/index.d.ts

@@ -0,0 +1,19 @@
+import { TextareaHTMLAttributes } from 'react';
+interface TextareaGenericProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    className?: string;
+}
+export interface TextareaWithUndefinedAutoHeightProps extends TextareaGenericProps {
+    autoHeight?: never;
+    maxHeight?: never;
+}
+export interface TextareaWithAutoHeightProps extends TextareaGenericProps {
+    autoHeight: true;
+    maxHeight?: string | number;
+}
+export interface TextareaWithoutAutoHeightProps extends TextareaGenericProps {
+    autoHeight: false;
+    maxHeight?: never;
+}
+export type TextareaProps = TextareaWithAutoHeightProps | TextareaWithoutAutoHeightProps | TextareaWithUndefinedAutoHeightProps;
+export declare const Textarea: import("react").ForwardRefExoticComponent<TextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;
+export {};

package/dist/types/components/Textarea/recipe.d.ts

@@ -0,0 +1,2 @@
+export declare const textAreaRecipe: import("../../styled-system/types").RecipeRuntimeFn<import("../../styled-system/types").RecipeVariantRecord>;
+export declare const textAreaWrapperRecipe: import("../../styled-system/types").RecipeRuntimeFn<import("../../styled-system/types").RecipeVariantRecord>;

package/dist/types/components/Toggle/index.d.ts

@@ -0,0 +1,5 @@
+import { SwitchProps } from '../../ui-kit/switch';
+export type ToggleProps = Pick<SwitchProps, 'checked' | 'children' | 'disabled' | 'className' | 'onCheckedChange'> & {
+    loading?: boolean;
+};
+export declare function Toggle(props: ToggleProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Tooltip/index.d.ts

@@ -0,0 +1,50 @@
+import React, { ReactElement } from 'react';
+import { RecipeVariantProps } from '../../styled-system/css';
+import { Tooltip as PTooltip } from '../../ui-kit/tooltip';
+type RootProps = React.ComponentProps<typeof PTooltip.Root>;
+export type GenericTooltipProps = {
+    tooltip: string | ReactElement;
+    placement?: NonNullable<RootProps['positioning']>['placement'];
+    delayToShow?: number;
+    delayToHide?: number;
+    offset?: [number, number];
+    className?: string;
+    disabled?: boolean;
+    children: ReactElement;
+    withArrow?: boolean;
+    usePortal?: boolean;
+    id?: string;
+};
+declare const tooltipRecipe: import("../../styled-system/types").SlotRecipeRuntimeFn<"content" | "arrow-tip", {
+    type: {
+        default: {
+            content: {
+                background: "neutral.3";
+                rounded: "sm";
+                color: "black";
+            };
+            'arrow-tip': {
+                background: "neutral.3!";
+            };
+        };
+        dropdown: {
+            content: {
+                background: "black";
+                rounded: "xl";
+                color: "white";
+                fontWeight: "medium";
+                px: "2";
+                py: "1.5";
+                maxW: "full";
+            };
+            'arrow-tip': {
+                background: "black!";
+            };
+        };
+    };
+}>;
+export type TooltipVariants = RecipeVariantProps<typeof tooltipRecipe>;
+export declare const Tooltip: React.ForwardRefExoticComponent<GenericTooltipProps & {
+    type?: "default" | "dropdown" | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/components/Truncate/index.d.ts

@@ -0,0 +1,11 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { GenericTooltipProps } from '../Tooltip';
+export declare function Truncate({ children, endLetters, className, id, placement, offset, usePortal, tooltipBuilder, ...rest }: {
+    children: string | ReactNode;
+    endLetters?: number;
+    className?: string;
+    placement?: GenericTooltipProps['placement'];
+    offset?: GenericTooltipProps['offset'];
+    usePortal?: GenericTooltipProps['usePortal'];
+    tooltipBuilder?: (children: GenericTooltipProps['tooltip']) => GenericTooltipProps['tooltip'];
+} & HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;

package/dist/types/contexts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './integration-app-context.js';
+export { useIntegrationApp } from './integration-app-context.js';

package/dist/types/contexts/integration-app-client-context.d.ts

@@ -0,0 +1,10 @@
+import { IntegrationAppClient } from '@membranehq/sdk';
+interface IIntegrationAppClientContext {
+    client: IntegrationAppClient;
+}
+export declare const IntegrationAppClientProvider: ({ client, children }: {
+    client: any;
+    children: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useIntegrationAppClient(): IIntegrationAppClientContext;
+export {};

package/dist/types/contexts/integration-app-connection-context.d.ts

@@ -0,0 +1,9 @@
+interface IIntegrationAppConnectionContext {
+    connectionId: string;
+}
+export declare const IntegrationAppConnectionProvider: ({ connectionId, children }: {
+    connectionId: any;
+    children: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useIntegrationAppConnection(): IIntegrationAppConnectionContext;
+export {};

package/dist/types/contexts/integration-app-context.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { IntegrationAppClient } from '@membranehq/sdk';
+interface IntegrationAppProviderProps {
+    token?: string;
+    fetchToken?: () => Promise<string>;
+    credentials?: any;
+    fetchCredentials?: () => Promise<any>;
+    apiUri?: string;
+    uiUri?: string;
+    children: ReactNode;
+}
+export declare const IntegrationAppProvider: ({ token, fetchToken, credentials, fetchCredentials, apiUri, uiUri, children, }: IntegrationAppProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare function useIntegrationApp(): IntegrationAppClient;
+export {};

package/dist/types/contexts/integration-app-integration-context.d.ts

@@ -0,0 +1,9 @@
+interface IIntegrationAppIntegrationContext {
+    integrationId: string;
+}
+export declare const IntegrationAppIntegrationProvider: ({ integrationId, children }: {
+    integrationId: any;
+    children: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useIntegrationAppIntegration(): IIntegrationAppIntegrationContext;
+export {};

package/dist/types/helpers/Debounce.d.ts

@@ -0,0 +1 @@
+export default function debounce<A = unknown, R = void>(fn: (args?: A) => R, ms: number): [(args?: A) => Promise<R>, () => void];

package/dist/types/helpers/getRefElement.d.ts

@@ -0,0 +1,3 @@
+import { ForwardedRef, MutableRefObject } from 'react';
+export type RefOrElementType<T = HTMLElement> = ForwardedRef<T | null> | MutableRefObject<T | null> | T | null;
+export declare function getRefElement<T>(ref?: RefOrElementType<T>): T | null;

package/dist/types/helpers/hooks/keyboard-events.d.ts

@@ -0,0 +1,18 @@
+import { MutableRefObject } from 'react';
+export declare enum EVENT_TYPE {
+    OPTION_DOWN = "option_down",
+    OPTION_UP = "option_up",
+    OPTION_RIGHT = "option_right",
+    OPTION_LEFT = "option_left",
+    OPTION_SELECT = "option_select",
+    FORM_SUBMIT = "form_submit"
+}
+type ScopedComboboxId = string;
+type CallbackFunctionType = (scopedComboboxId: ScopedComboboxId) => void;
+export declare function useOptionListKeyNavDispatch(ref: (HTMLElement | MutableRefObject<HTMLElement> | null) | undefined, scopedComboboxId: string): void;
+export declare function useKeyboardEventSubscribe({ scopedComboboxId, event, callback, }: {
+    scopedComboboxId: string;
+    event: EVENT_TYPE;
+    callback: CallbackFunctionType;
+}): void;
+export {};

package/dist/types/helpers/hooks/subscriptionStack.d.ts

@@ -0,0 +1,4 @@
+export declare const createSubscriptionStackHook: () => (subscribe: Subscribe, deps: Array<any>) => void;
+type Unsubscribe = () => void;
+type Subscribe = () => Unsubscribe;
+export {};

package/dist/types/helpers/hooks/useAutofocus.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare function useAutofocus(elementRef: RefObject<HTMLElement>, autoFocus: boolean): void;