@plitzi/plitzi-builder 0.30.19

package/dist/modules/Collection/components/CollectionField.d.ts

@@ -0,0 +1,11 @@
+import { fieldTypes } from '@plitzi/sdk-collections/CollectionsHelper';
+export type CollectionFieldProps = {
+    isNewField?: boolean;
+    name?: string;
+    machineName?: string;
+    type?: keyof typeof fieldTypes;
+    params?: object;
+    onRemove?: () => void;
+};
+declare const CollectionField: ({ name, machineName, type, params, onRemove }: CollectionFieldProps) => import("react/jsx-runtime").JSX.Element;
+export default CollectionField;

package/dist/modules/Collection/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/DataSource/BindingSelected.d.ts

@@ -0,0 +1,18 @@
+import { RuleGroup } from '@plitzi/plitzi-ui/QueryBuilder';
+import { BindingTransformer, SourceMeta, BindingCategory } from '@plitzi/sdk-shared';
+export type BindingSelected = {
+    id?: string;
+    sources?: Record<string, SourceMeta>;
+    category?: string;
+    fromPath?: string;
+    toPath?: string;
+    source?: string;
+    transformers?: BindingTransformer[];
+    when?: RuleGroup;
+    enabled?: boolean;
+    onEnable?: (category: BindingCategory, id: string, enabled: boolean) => void;
+    onUpdate?: (category: BindingCategory, id: string) => void;
+    onRemove?: (category: BindingCategory, id: string) => void;
+};
+declare const BindingSelected: ({ id, sources, category, fromPath, toPath, source, transformers, when, enabled, onEnable, onUpdate, onRemove }: BindingSelected) => import("react/jsx-runtime").JSX.Element;
+export default BindingSelected;

package/dist/modules/DataSource/DataSourceBinding.d.ts

@@ -0,0 +1,9 @@
+import { Element } from '@plitzi/sdk-shared';
+export type DataSourceBindingProps = {
+    id?: string;
+    bindings?: Element['definition']['bindings'];
+    element: Element;
+    onChange?: (bindings: Element['definition']['bindings']) => void;
+};
+declare const DataSourceBinding: ({ id, bindings, element, onChange }: DataSourceBindingProps) => import("react/jsx-runtime").JSX.Element;
+export default DataSourceBinding;

package/dist/modules/DataSource/helpers/transformerString.d.ts

@@ -0,0 +1,6 @@
+declare const transformerString: (transformers?: {
+    type: "unknown" | "utility";
+    action: string;
+    params: Record<string, any>;
+}[]) => string;
+export default transformerString;

package/dist/modules/DataSource/helpers/whenString.d.ts

@@ -0,0 +1,3 @@
+import { RuleGroup } from '@plitzi/plitzi-ui/QueryBuilder';
+declare const whenString: (when?: RuleGroup) => string;
+export default whenString;

package/dist/modules/DataSource/models/BindingForm/BindingForm.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { ElementBinding, SourceMeta } from '@plitzi/sdk-shared';
+export declare const bindingForm: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    fromPath: z.ZodString;
+    toPath: z.ZodString;
+    when: z.ZodOptional<z.ZodAny>;
+    transformers: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            unknown: "unknown";
+            utility: "utility";
+        }>;
+        action: z.ZodString;
+        params: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BindingSchema = z.infer<typeof bindingForm>;
+export type BindingFormProps = {
+    category?: string;
+    attributes?: {
+        label: string;
+        path: string;
+    }[];
+    sources: Record<string, SourceMeta>;
+    value?: ElementBinding;
+    onClose?: (success: boolean, data?: ElementBinding) => void;
+};
+declare const BindingForm: ({ category, attributes, sources, value, onClose }: BindingFormProps) => import("react/jsx-runtime").JSX.Element;
+export default BindingForm;

package/dist/modules/DataSource/models/BindingForm/index.d.ts

@@ -0,0 +1,3 @@
+import { default as BindingForm } from './BindingForm';
+export * from './BindingForm';
+export default BindingForm;

package/dist/modules/DataSource/models/BindingForm/steps/StepPreview.d.ts

@@ -0,0 +1,8 @@
+import { SourceField, SourceMeta } from '@plitzi/sdk-shared';
+export type StepPreviewProps = {
+    category?: string;
+    fields?: SourceField[];
+    sources?: Record<string, SourceMeta>;
+};
+declare const StepPreview: ({ category, fields, sources }: StepPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export default StepPreview;

package/dist/modules/DataSource/models/BindingForm/steps/StepSettings.d.ts

@@ -0,0 +1,11 @@
+import { SourceField } from '@plitzi/sdk-shared';
+export type StepSettingsProps = {
+    source: string;
+    fields: SourceField[];
+    attributes?: {
+        label: string;
+        path: string;
+    }[];
+};
+declare const StepSettings: ({ source, fields, attributes }: StepSettingsProps) => import("react/jsx-runtime").JSX.Element;
+export default StepSettings;

package/dist/modules/DataSource/models/BindingForm/steps/StepSource.d.ts

@@ -0,0 +1,6 @@
+import { SourceMeta } from '@plitzi/sdk-shared';
+export type StepSourceProps = {
+    sources: Record<string, SourceMeta>;
+};
+declare const StepSource: ({ sources }: StepSourceProps) => import("react/jsx-runtime").JSX.Element;
+export default StepSource;

package/dist/modules/DataSource/models/BindingForm/steps/StepTransformers/StepTransformers.d.ts

@@ -0,0 +1,6 @@
+import { SourceField } from '@plitzi/sdk-shared';
+export type StepTransformersProps = {
+    dataSourceFields?: Record<string, SourceField[]>;
+};
+declare const StepTransformers: ({ dataSourceFields }: StepTransformersProps) => import("react/jsx-runtime").JSX.Element;
+export default StepTransformers;

package/dist/modules/DataSource/models/BindingForm/steps/StepTransformers/TransformerParam.d.ts

@@ -0,0 +1,16 @@
+import { Option } from '@plitzi/plitzi-ui/Select2';
+import { DataSourceUtilityParamType, SourceField } from '@plitzi/sdk-shared';
+export type TransformerParamProps = {
+    id?: string;
+    type?: DataSourceUtilityParamType;
+    label?: string;
+    description?: string;
+    value?: string | number | boolean;
+    index: number;
+    options?: Option[] | Promise<Option[]>;
+    dataSourceFields?: Record<string, SourceField[]>;
+    disabled?: boolean;
+    onChange?: (index: number, id: string, value: string | number | boolean) => void;
+};
+declare const TransformerParam: ({ id, type, label: labelProp, description, value, index, options, dataSourceFields, disabled, onChange }: TransformerParamProps) => import("react/jsx-runtime").JSX.Element;
+export default TransformerParam;

package/dist/modules/DataSource/models/BindingForm/steps/StepTransformers/index.d.ts

@@ -0,0 +1,3 @@
+import { default as StepTransformers } from './StepTransformers';
+export * from './StepTransformers';
+export default StepTransformers;

package/dist/modules/DataSource/models/BindingForm/steps/StepWhen.d.ts

@@ -0,0 +1,6 @@
+import { SourceField } from '@plitzi/sdk-shared';
+export type StepWhenProps = {
+    dataSourceFields?: Record<string, SourceField[]>;
+};
+declare const StepWhen: ({ dataSourceFields }: StepWhenProps) => import("react/jsx-runtime").JSX.Element;
+export default StepWhen;

package/dist/modules/Elements/Element.d.ts

@@ -0,0 +1,6 @@
+import { ComponentDefinition } from '@plitzi/sdk-shared';
+export type ElementProps = {
+    component: ComponentDefinition;
+};
+declare const Element: ({ component: { market: { icon }, definition: { label, type } } }: ElementProps) => import("react/jsx-runtime").JSX.Element;
+export default Element;

package/dist/modules/Elements/ElementCategory.d.ts

@@ -0,0 +1,7 @@
+import { ComponentDefinition } from '@plitzi/sdk-shared';
+export type ElementCategoryProps = {
+    components?: ComponentDefinition[];
+    category?: string;
+};
+declare const ElementCategory: ({ components, category }: ElementCategoryProps) => import("react/jsx-runtime").JSX.Element | undefined;
+export default ElementCategory;

package/dist/modules/Elements/ElementHelper.d.ts

@@ -0,0 +1,5 @@
+import { ComponentDefinition, Element } from '@plitzi/sdk-shared';
+export declare const getInitialItems: (parentId: string, items: string[] | undefined, definitions: Record<string, ComponentDefinition>, rootId?: string) => {
+    directItems: Record<string, Element>;
+    items: Record<string, Element>;
+};

package/dist/modules/Elements/Elements.d.ts

@@ -0,0 +1,2 @@
+declare const Elements: () => import("react/jsx-runtime").JSX.Element;
+export default Elements;

package/dist/modules/Elements/hooks/useDragElement.d.ts

@@ -0,0 +1,13 @@
+import { Template } from '@plitzi/sdk-shared';
+import { DragEvent } from 'react';
+export type UseDragElementProps = {
+    attributes?: Record<string, unknown>;
+    type: string;
+    variables?: object[];
+    manifest?: Template;
+    onParentRefresh?: (identifier: string, segment: object) => void;
+};
+declare const useDragElement: ({ attributes, type, variables, manifest }: UseDragElementProps) => {
+    onDragStart: (e: DragEvent) => void;
+};
+export default useDragElement;

package/dist/modules/Elements/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Elements } from './Elements';
+export * from './Elements';
+export default Elements;

package/dist/modules/Integrations/Integrations.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/Interactions/Interactions.d.ts

@@ -0,0 +1,9 @@
+import { Element } from '@plitzi/sdk-shared';
+export type InteractionsProps = {
+    className?: string;
+    id?: string;
+    interactions?: Element['definition']['interactions'];
+    onChange?: (interactions: Element['definition']['interactions']) => void;
+};
+declare const Interactions: ({ className, id, interactions, onChange }: InteractionsProps) => import("react/jsx-runtime").JSX.Element;
+export default Interactions;

package/dist/modules/Interactions/InteractionsBuilderContextProvider.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export type InteractionsBuilderContextProviderProps = {
+    children?: ReactNode;
+    previewMode?: boolean;
+};
+declare const InteractionsBuilderContextProvider: ({ children, previewMode }: InteractionsBuilderContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default InteractionsBuilderContextProvider;

package/dist/modules/Interactions/components/Workflow/Workflow.d.ts

@@ -0,0 +1,11 @@
+import { ElementInteraction, InteractionCallback } from '@plitzi/sdk-shared';
+export type WorkflowProps = {
+    nodes?: Record<string, ElementInteraction>;
+    triggerTitle?: string;
+    callbackTitle?: string;
+    nodeDefinitions?: InteractionCallback[];
+    direction?: 'horizontal' | 'vertical';
+    onChange?: (nodes: Record<string, ElementInteraction>) => void;
+};
+declare const Workflow: ({ nodes: nodesProp, triggerTitle, callbackTitle, nodeDefinitions, direction, onChange }: WorkflowProps) => import("react/jsx-runtime").JSX.Element;
+export default Workflow;

package/dist/modules/Interactions/components/Workflow/WorkflowAddNode.d.ts

@@ -0,0 +1,10 @@
+export type WorkflowAddNodeProps = {
+    topOpened?: boolean;
+    bottomOpened?: boolean;
+    concatenateTop?: boolean;
+    concatenateBottom?: boolean;
+    id?: string;
+    onClick?: (id: string) => void;
+};
+declare const WorkflowAddNode: ({ topOpened, bottomOpened, concatenateTop, concatenateBottom, id, onClick }: WorkflowAddNodeProps) => import("react/jsx-runtime").JSX.Element;
+export default WorkflowAddNode;

package/dist/modules/Interactions/components/Workflow/WorkflowContext.d.ts

@@ -0,0 +1,21 @@
+import { ElementInteraction, InteractionCallback, Source, SourceField } from '@plitzi/sdk-shared';
+export type WorkflowContextValue = {
+    direction: 'horizontal' | 'vertical';
+    nodeDefinitions?: InteractionCallback[];
+    previewData: Record<string, ElementInteraction['preview']>;
+    dataSource: Record<string, Source['meta']>;
+    dataSourceContent: Record<string, SourceField[]>;
+    addNode: (nodeType: ElementInteraction['type'], siblingNodeId?: string, flowId?: string) => void;
+    updateNode: (node: ElementInteraction) => void;
+    removeNode: (nodeId: string) => void;
+    getNode: {
+        (nodeId: string): ElementInteraction;
+        (): Record<string, ElementInteraction>;
+    };
+    getPreviousNodes: (nodeId: string, skipTrigger?: boolean) => ElementInteraction[];
+    getDefinition: (type: ElementInteraction['type'], action: string, elementId?: string) => InteractionCallback | undefined;
+    moveNode: (nodeId: string, direction?: 'up' | 'down') => void;
+    setPreviewNode: (id: string, data?: ElementInteraction['preview']) => void;
+};
+declare const WorkflowContext: import('react').Context<WorkflowContextValue>;
+export default WorkflowContext;

package/dist/modules/Interactions/components/Workflow/WorkflowContextProvider.d.ts

@@ -0,0 +1,12 @@
+import { ElementInteraction, InteractionCallback } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+export type WorkflowContextProviderProps = {
+    children: ReactNode;
+    nodes: Record<string, ElementInteraction>;
+    direction: 'horizontal' | 'vertical';
+    nodeDefinitions?: InteractionCallback[];
+    onChange: (nodes: Record<string, ElementInteraction>, debounced?: boolean) => void;
+    setFlowId: (flowId: string) => void;
+};
+declare const WorkflowContextProvider: ({ children, nodes, direction, nodeDefinitions, setFlowId, onChange }: WorkflowContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default WorkflowContextProvider;

package/dist/modules/Interactions/components/Workflow/WorkflowFlow.d.ts

@@ -0,0 +1,9 @@
+import { ElementInteraction } from '@plitzi/sdk-shared';
+export type WorkflowFlowProps = {
+    trigger: ElementInteraction;
+    nodes?: Record<string, ElementInteraction>;
+    triggerTitle?: string;
+    callbackTitle?: string;
+};
+declare const WorkflowFlow: ({ trigger, nodes, triggerTitle, callbackTitle }: WorkflowFlowProps) => import("react/jsx-runtime").JSX.Element;
+export default WorkflowFlow;

package/dist/modules/Interactions/components/Workflow/WorkflowHeader.d.ts

@@ -0,0 +1,14 @@
+import { ElementInteraction } from '@plitzi/sdk-shared';
+import { Dispatch, SetStateAction } from 'react';
+export type WorkflowHeaderProps = {
+    flows: {
+        id: string;
+        title: string;
+        trigger: ElementInteraction;
+        nodes: Record<string, ElementInteraction>;
+    }[];
+    flowId?: string;
+    setFlowId: Dispatch<SetStateAction<string | undefined>>;
+};
+declare const WorkflowHeader: ({ flows, flowId, setFlowId }: WorkflowHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export default WorkflowHeader;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/NodeBody.d.ts

@@ -0,0 +1,15 @@
+import { ElementInteraction, InteractionCallbackParam, InteractionCallbackParamValues } from '@plitzi/sdk-shared';
+export type NodeBodyProps = {
+    id?: string;
+    params?: InteractionCallbackParamValues;
+    paramDefinitions: Record<string, InteractionCallbackParam>;
+    fields: Record<string, {
+        name: string;
+        label: string;
+        placeholder: string;
+        group: string;
+    }>;
+    onChange?: (params: Partial<ElementInteraction>) => void;
+};
+declare const NodeBody: ({ id, params, paramDefinitions, fields, onChange }: NodeBodyProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeBody;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/NodeBodyParam.d.ts

@@ -0,0 +1,22 @@
+import { Option } from '@plitzi/plitzi-ui/Select2';
+import { ElementInteraction, InteractionParamType } from '@plitzi/sdk-shared';
+export type NodeBodyParamProps = {
+    className?: string;
+    nodeId?: string;
+    id: keyof ElementInteraction;
+    label?: string;
+    value?: string | boolean | number;
+    type?: InteractionParamType | ((params: Record<string, unknown>) => InteractionParamType);
+    options?: Option[] | ((params: Record<string, unknown>) => Option[]);
+    canBind?: boolean;
+    params?: Record<string, unknown>;
+    fields: Record<string, {
+        name: string;
+        label: string;
+        placeholder: string;
+        group: string;
+    }>;
+    onChange?: (id: keyof ElementInteraction, value: string | boolean | number) => void;
+};
+declare const NodeBodyParam: ({ className, nodeId, id, label, value, type: typeProp, options: optionsProp, canBind, params, fields, onChange }: NodeBodyParamProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeBodyParam;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/NodeFooter.d.ts

@@ -0,0 +1,5 @@
+export type NodeFooterProps = {
+    onClickOpen?: () => void;
+};
+declare const NodeFooter: ({ onClickOpen }: NodeFooterProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeFooter;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/NodeHeader.d.ts

@@ -0,0 +1,21 @@
+import { ElementInteraction, InteractionCallback } from '@plitzi/sdk-shared';
+export type NodeHeaderProps = {
+    className?: string;
+    id?: string;
+    title?: string;
+    type?: 'trigger' | 'callback' | 'utility' | 'globalCallback';
+    action?: string;
+    elementId?: string;
+    canDelete?: boolean;
+    isOpened?: boolean;
+    enabled?: boolean;
+    nodeDefinitions?: InteractionCallback[];
+    nodeDefinition?: InteractionCallback;
+    canUp?: boolean;
+    canDown?: boolean;
+    onChange?: (node: Partial<ElementInteraction>) => void;
+    onClickOpen?: () => void;
+    onClickRemove?: () => void;
+};
+declare const NodeHeader: ({ className, id, title, type, action, elementId, canDelete, isOpened, enabled, nodeDefinitions, nodeDefinition, canUp, canDown, onChange, onClickOpen, onClickRemove }: NodeHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeHeader;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/NodePreview.d.ts

@@ -0,0 +1,8 @@
+export type NodePreviewProps = {
+    preview?: Record<string, unknown>;
+    defaultPreview?: Record<string, unknown>;
+    onChange?: (data: Record<string, unknown>) => void;
+    onClickOpen?: () => void;
+};
+declare const NodePreview: ({ preview, defaultPreview, onChange }: NodePreviewProps) => import("react/jsx-runtime").JSX.Element;
+export default NodePreview;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/NodeWhen.d.ts

@@ -0,0 +1,10 @@
+import { Field, RuleGroup } from '@plitzi/plitzi-ui/QueryBuilder';
+export type NodeWhenProps = {
+    when?: RuleGroup;
+    fields?: Record<string, Field>;
+    onChange?: (data: {
+        when: RuleGroup;
+    }) => void;
+};
+declare const NodeWhen: ({ when, fields, onChange }: NodeWhenProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeWhen;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/ParamBinding.d.ts

@@ -0,0 +1,10 @@
+import { ElementInteraction } from '@plitzi/sdk-shared';
+export type ParamBindingProps = {
+    className?: string;
+    nodeId?: string;
+    id: keyof ElementInteraction;
+    value?: string;
+    onChange?: (id: keyof ElementInteraction, value: string | boolean | number) => void;
+};
+declare const ParamBinding: ({ nodeId: nodeIdProp, id, value, onChange }: ParamBindingProps) => import("react/jsx-runtime").JSX.Element;
+export default ParamBinding;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/WorkflowNode.d.ts

@@ -0,0 +1,22 @@
+import { RuleGroup } from '@plitzi/plitzi-ui/QueryBuilder';
+import { InteractionCallbackParamValues } from '@plitzi/sdk-shared';
+export type WorkflowNodeProps = {
+    id?: string;
+    title?: string;
+    type?: 'trigger' | 'callback' | 'utility' | 'globalCallback';
+    canDelete?: boolean;
+    action?: string;
+    elementId?: string;
+    enabled?: boolean;
+    beforeNode?: string;
+    afterNode?: string;
+    triggerId?: string;
+    params?: InteractionCallbackParamValues;
+    when?: RuleGroup;
+    preview?: Record<string, unknown>;
+    isOpened?: boolean;
+    onOpened?: (id: string, isOpened: boolean) => void;
+    onRemove?: (id: string) => void;
+};
+declare const _default: import('react').MemoExoticComponent<({ id, title, type, canDelete, action, elementId, enabled, beforeNode, afterNode, triggerId, params, when, preview, isOpened, onOpened, onRemove }: WorkflowNodeProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/modules/Interactions/components/Workflow/WorkflowNode/index.d.ts

@@ -0,0 +1,3 @@
+import { default as WorkflowNode } from './WorkflowNode';
+export * from './WorkflowNode';
+export default WorkflowNode;

package/dist/modules/Interactions/components/Workflow/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Workflow } from './Workflow';
+export * from './Workflow';
+export default Workflow;

package/dist/modules/Interactions/sources/CollectionSource/CollectionInteractions.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export type CollectionInteractionsProps = {
+    children?: ReactNode;
+};
+declare const CollectionInteractions: ({ children }: CollectionInteractionsProps) => ReactNode;
+export default CollectionInteractions;

package/dist/modules/Interactions/sources/PageSource/PageInteractions.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export type PageInteractionsProps = {
+    children?: ReactNode;
+    previewMode?: boolean;
+};
+declare const PageInteractions: ({ children, previewMode }: PageInteractionsProps) => ReactNode;
+export default PageInteractions;

package/dist/modules/Marketplace/Marketplace.d.ts

@@ -0,0 +1,2 @@
+declare const Marketplace: () => import("react/jsx-runtime").JSX.Element;
+export default Marketplace;

package/dist/modules/Marketplace/components/MarketNews/MarketNews.d.ts

@@ -0,0 +1,2 @@
+declare const MarketNews: () => import("react/jsx-runtime").JSX.Element;
+export default MarketNews;

package/dist/modules/Marketplace/components/MarketNews/index.d.ts

@@ -0,0 +1,3 @@
+import { default as MarketNews } from './MarketNews';
+export * from './MarketNews';
+export default MarketNews;

package/dist/modules/Marketplace/components/MarketPlugins/MarketPlugins.d.ts

@@ -0,0 +1,2 @@
+declare const MarketPlugins: () => import("react/jsx-runtime").JSX.Element;
+export default MarketPlugins;

package/dist/modules/Marketplace/components/MarketPlugins/PluginDetails/DetailsContent.d.ts

@@ -0,0 +1,2 @@
+declare const DetailsContent: () => import("react/jsx-runtime").JSX.Element;
+export default DetailsContent;

package/dist/modules/Marketplace/components/MarketPlugins/PluginDetails/DetailsSidebar.d.ts

@@ -0,0 +1,19 @@
+export type DetailsSidebarProps = {
+    name?: string;
+    description?: string;
+    createdAt?: number;
+    icon?: string;
+    revisions?: {
+        version: string;
+    }[];
+    owner?: string;
+    website?: string;
+    color?: string;
+    version: string;
+    latestVersion: string;
+    onAdd?: (version: string) => void;
+    onUpdate?: (version: string) => Promise<boolean>;
+    onRemove?: () => void;
+};
+declare const DetailsSidebar: ({ name, description, createdAt, icon, revisions, owner, website, color, version: versionInstalled, latestVersion, onAdd, onUpdate, onRemove }: DetailsSidebarProps) => import("react/jsx-runtime").JSX.Element;
+export default DetailsSidebar;

package/dist/modules/Marketplace/components/MarketPlugins/PluginDetails/PluginDetails.d.ts

@@ -0,0 +1,23 @@
+import { MarketPlacePlugin } from '../../../types';
+import { Dispatch, SetStateAction } from 'react';
+export type PluginDetailsProps = {
+    name?: string;
+    description?: string;
+    type?: string;
+    latestVersion: string;
+    version: string;
+    revisions: {
+        version: string;
+    }[];
+    icon?: string;
+    color?: string;
+    owner?: string;
+    website?: string;
+    createdAt?: number;
+    setPluginSelected?: Dispatch<SetStateAction<MarketPlacePlugin | undefined>>;
+    onAdd?: (version: string) => void;
+    onUpdate?: (version: string) => Promise<boolean>;
+    onRemove?: () => void;
+};
+declare const PluginDetails: ({ name, description, icon, color, owner, website, revisions, version, latestVersion, createdAt, setPluginSelected, onAdd, onUpdate, onRemove }: PluginDetailsProps) => import("react/jsx-runtime").JSX.Element;
+export default PluginDetails;

package/dist/modules/Marketplace/components/MarketPlugins/PluginDetails/index.d.ts

@@ -0,0 +1,3 @@
+import { default as PluginDetails } from './PluginDetails';
+export * from './PluginDetails';
+export default PluginDetails;

package/dist/modules/Marketplace/components/MarketPlugins/PluginItem.d.ts

@@ -0,0 +1,14 @@
+export type PluginItemProps = {
+    className?: string;
+    name?: string;
+    description?: string;
+    type?: string;
+    latestVersion?: string;
+    version?: string;
+    icon?: string;
+    website?: string;
+    color?: string;
+    onClick?: (type: string) => void;
+};
+declare const PluginItem: ({ className, name, type, description, latestVersion, version, icon, website, color, onClick }: PluginItemProps) => import("react/jsx-runtime").JSX.Element;
+export default PluginItem;

package/dist/modules/Marketplace/components/MarketPlugins/PluginList.d.ts

@@ -0,0 +1,7 @@
+import { MarketPlacePluginRaw } from '../../types';
+export type PluginListProps = {
+    plugins?: MarketPlacePluginRaw[];
+    onClick?: (plugin: string) => void;
+};
+declare const PluginList: ({ plugins, onClick }: PluginListProps) => import("react/jsx-runtime").JSX.Element;
+export default PluginList;

package/dist/modules/Marketplace/components/MarketPlugins/PluginsFilter/FilterCategory.d.ts

@@ -0,0 +1,9 @@
+export type FilterCategoryProps = {
+    className?: string;
+    id?: string;
+    active?: boolean;
+    name?: string;
+    onClick?: (id: string) => void;
+};
+declare const FilterCategory: ({ className, id, active, name, onClick }: FilterCategoryProps) => import("react/jsx-runtime").JSX.Element;
+export default FilterCategory;

package/dist/modules/Marketplace/components/MarketPlugins/PluginsFilter/PluginsFilter.d.ts

@@ -0,0 +1,13 @@
+export type PluginsFilterProps = {
+    filter: {
+        name: {
+            contains: string;
+        };
+        owner: {
+            contains: string;
+        };
+    };
+    onChange?: (value: string, key?: string) => void;
+};
+declare const PluginsFilter: ({ filter, onChange }: PluginsFilterProps) => import("react/jsx-runtime").JSX.Element;
+export default PluginsFilter;

package/dist/modules/Marketplace/components/MarketPlugins/PluginsFilter/index.d.ts

@@ -0,0 +1,3 @@
+import { default as PluginsFilter } from './PluginsFilter';
+export * from './PluginsFilter';
+export default PluginsFilter;

package/dist/modules/Marketplace/components/MarketPlugins/index.d.ts

@@ -0,0 +1,3 @@
+import { default as MarketPlugins } from './MarketPlugins';
+export * from './MarketPlugins';
+export default MarketPlugins;

package/dist/modules/Marketplace/components/MarketSidebar.d.ts

@@ -0,0 +1,6 @@
+export type MarketSidebarProps = {
+    className?: string;
+    onSelect?: (option: string) => void;
+};
+declare const MarketSidebar: ({ className, onSelect }: MarketSidebarProps) => import("react/jsx-runtime").JSX.Element;
+export default MarketSidebar;

package/dist/modules/Marketplace/components/MarketSidebarItem.d.ts

@@ -0,0 +1,9 @@
+export type MarketSidebarItemProps = {
+    id?: string;
+    isSelected?: boolean;
+    className?: string;
+    children?: React.ReactNode;
+    onClick?: (id: string) => void;
+};
+declare const MarketSidebarItem: ({ id, isSelected, className, children, onClick }: MarketSidebarItemProps) => import("react/jsx-runtime").JSX.Element;
+export default MarketSidebarItem;