@akbarsafari00/bonyan-content-type-builder 5.52.1-fa.2

package/dist/admin/src/components/AttributeOptions/OptionBoxWrapper.d.ts

@@ -0,0 +1,13 @@
+export declare const OptionBoxWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
+    children?: React.ReactNode;
+} & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+    ref?: any;
+}, "ref"> & {
+    ref?: any;
+}, never> & Partial<Pick<Omit<import("@strapi/design-system").TransientBoxProps & {
+    children?: React.ReactNode;
+} & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+    ref?: any;
+}, "ref"> & {
+    ref?: any;
+}, never>>> & string & Omit<import("@strapi/design-system").BoxComponent<"div">, keyof import("react").Component<any, {}, any>>;

package/dist/admin/src/components/AttributeRow.d.ts

@@ -0,0 +1,32 @@
+import type { AnyAttribute, Component, ContentType } from '../types';
+import type { DraggableAttributes, DraggableSyntheticListeners } from '@dnd-kit/core';
+import type { UID } from '@strapi/types';
+export declare const GridWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
+}, "$isOverlay" | "$isDragging"> & {
+    $isOverlay?: boolean;
+    $isDragging?: boolean;
+}, never> & Partial<Pick<import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
+}, "$isOverlay" | "$isDragging"> & {
+    $isOverlay?: boolean;
+    $isDragging?: boolean;
+}, never>>> & string & Omit<(<C extends React.ElementType<any, keyof React.JSX.IntrinsicElements> = "div">(props: React.PropsWithoutRef<import("@strapi/design-system").FlexProps<C>> & React.RefAttributes<unknown>) => React.ReactNode), keyof import("react").Component<any, {}, any>>;
+export type AttributeRowProps = {
+    item: {
+        id: string;
+        index: number;
+    } & AnyAttribute;
+    firstLoopComponentUid?: UID.Component | null;
+    isFromDynamicZone?: boolean;
+    addComponentToDZ?: () => void;
+    secondLoopComponentUid?: UID.Component | null;
+    type: ContentType | Component;
+    isDragging?: boolean;
+    style?: Record<string, unknown>;
+    listeners?: DraggableSyntheticListeners;
+    attributes?: DraggableAttributes;
+    isOverlay?: boolean;
+    handleRef?: (element: HTMLElement | null) => void;
+};
+export declare const AttributeRow: import("react").ForwardRefExoticComponent<AttributeRowProps & import("react").RefAttributes<HTMLLIElement>>;

package/dist/admin/src/components/AutoReloadOverlayBlocker.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+/**
+ * TODO: realistically a lot of this logic is isolated to the `core/admin` package.
+ * However, we want to expose the `useAutoReloadOverlayBlocker` hook to the plugins.
+ *
+ * Therefore, in V5 we should move this logic back to the `core/admin` package & export
+ * the hook from that package and re-export here. For now, let's keep it all together
+ * because it's easier to diagnose and we're not using a million refs because we don't
+ * understand what's going on.
+ */
+export interface AutoReloadOverlayBlockerConfig {
+    title?: string;
+    description?: string;
+    icon?: 'reload' | 'time';
+}
+export interface AutoReloadOverlayBlockerContextValue {
+    lockAppWithAutoreload: (config?: AutoReloadOverlayBlockerConfig) => void;
+    unlockAppWithAutoreload: () => void;
+}
+export interface AutoReloadOverlayBlockerProviderProps {
+    children: React.ReactNode;
+}
+declare const AutoReloadOverlayBlockerProvider: ({ children }: AutoReloadOverlayBlockerProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useAutoReloadOverlayBlocker: () => AutoReloadOverlayBlockerContextValue;
+export { AutoReloadOverlayBlockerProvider, useAutoReloadOverlayBlocker };

package/dist/admin/src/components/BooleanDefaultValueSelect.d.ts

@@ -0,0 +1,20 @@
+import type { FormChangeHandler, IntlLabel } from '../types';
+interface Metadata {
+    intlLabel: IntlLabel;
+    disabled?: boolean;
+    hidden?: boolean;
+}
+interface Option {
+    metadatas: Metadata;
+    key: string | number;
+    value: string | number;
+}
+interface BooleanDefaultValueSelectProps {
+    intlLabel: IntlLabel;
+    name: string;
+    onChange: FormChangeHandler<boolean | string, 'select-default-boolean'>;
+    options: Option[];
+    value?: boolean | string | null;
+}
+export declare const BooleanDefaultValueSelect: ({ intlLabel, name, options, onChange, value, }: BooleanDefaultValueSelectProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/BooleanRadioGroup.d.ts

@@ -0,0 +1,8 @@
+import type { FormChangeHandler, IntlLabel } from '../types';
+interface BooleanRadioGroupProps {
+    intlLabel: IntlLabel;
+    name: string;
+    onChange: FormChangeHandler<boolean, 'boolean-radio-group'>;
+}
+export declare const BooleanRadioGroup: ({ onChange, name, intlLabel, ...rest }: BooleanRadioGroupProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/CTBSession/CTBSessionProvider.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from 'react';
+interface CTBSessionProviderProps {
+    children: ReactNode;
+}
+/**
+ * Generates a unique session identifier for CTB tracking
+ * Uses crypto.randomUUID() for guaranteed uniqueness and readability
+ *
+ * @returns Session ID in format: ctb-{uuid}
+ */
+export declare const generateSessionId: () => string | undefined;
+/**
+ * Provider for CTB session tracking context.
+ *
+ * This provider should wrap components that need to track CTB events with session IDs.
+ * It manages the session ID lifecycle and provides methods to regenerate it when needed.
+ *
+ * Usage:
+ * ```tsx
+ * <CTBSessionProvider>
+ *       {children}
+ * </CTBSessionProvider>
+ * ```
+ */
+export declare const CTBSessionProvider: ({ children }: CTBSessionProviderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/CTBSession/ctbSession.d.ts

@@ -0,0 +1,5 @@
+export { CTBSessionProvider, generateSessionId } from './CTBSessionProvider';
+export { CTBSessionContext } from './sessionContext';
+export { useCTBSession } from './useCTBSession';
+export { useCTBTracking } from './useCTBTracking';
+export type { CTBSessionContextValue } from './sessionContext';

package/dist/admin/src/components/CTBSession/sessionContext.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Context for managing CTB (Content Type Builder) session tracking.
+ *
+ * Session Lifecycle:
+ * - Created: When CTBSessionProvider mounts
+ * - Regenerated: After server restart, when navigating back to CTB from another page
+ * - Used: Automatically attached to all CTB tracking events
+ *
+ * The session ID groups related tracking events together to understand user workflows
+ * within a single CTB session.
+ */
+export interface CTBSessionContextValue {
+    /**
+     * Unique identifier for the current CTB session
+     * Format: ctb-{uuid}
+     */
+    sessionId: string | undefined;
+    /**
+     * Generates and sets a new session ID
+     * Called when starting a new CTB session (e.g., after navigation or server restart)
+     */
+    regenerateSessionId: () => void;
+}
+export declare const CTBSessionContext: import("react").Context<CTBSessionContextValue | null>;

package/dist/admin/src/components/CTBSession/useCTBSession.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hook to access the current CTB session context.
+ *
+ * @throws Error if used outside of CTBSessionProvider
+ * @returns The CTB session context containing sessionId and regenerateSessionId
+ *
+ * @example
+ * ```tsx
+ * const { sessionId, regenerateSessionId } = useCTBSession();
+ * ```
+ */
+export declare const useCTBSession: () => import("./sessionContext").CTBSessionContextValue;

package/dist/admin/src/components/CTBSession/useCTBTracking.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Hook that provides tracking functionality with automatic CTB session ID inclusion.
+ * This version accepts arbitrary event names (string) to allow feature-specific
+ * events that are not yet declared in the central tracking typings.
+ *
+ * Note: this intentionally relaxes TypeScript restrictions so callers can
+ * emit new tracking event names without needing to update the upstream
+ * tracking type definitions. The session ID is merged into the properties
+ * object before forwarding to the original tracking implementation.
+ */
+export declare const useCTBTracking: () => {
+    trackUsage: (event: string, properties?: Record<string, unknown>) => Promise<import("axios").AxiosResponse<string, any, {}, any> | null>;
+};

package/dist/admin/src/components/CheckboxWithNumberField.d.ts

@@ -0,0 +1,13 @@
+import type { FormChangeHandler, IntlLabel } from '../types';
+interface CheckboxWithNumberFieldProps {
+    error?: string;
+    intlLabel: IntlLabel;
+    modifiedData: {
+        type?: string;
+    };
+    name: string;
+    onChange: FormChangeHandler<string | number | null>;
+    value?: string | number | null;
+}
+export declare const CheckboxWithNumberField: ({ error, intlLabel, modifiedData, name, onChange, value, }: CheckboxWithNumberFieldProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/ComponentCard/ComponentCard.d.ts

@@ -0,0 +1,14 @@
+import type { Internal, Struct } from '@strapi/types';
+interface ComponentCardProps {
+    component: string;
+    dzName: string;
+    index: number;
+    isActive?: boolean;
+    isInDevelopmentMode?: boolean;
+    onClick?: () => void;
+    forTarget: Struct.ModelType;
+    targetUid: Internal.UID.Schema;
+    disabled?: boolean;
+}
+export declare const ComponentCard: ({ component, dzName, index, isActive, isInDevelopmentMode, onClick, forTarget, targetUid, disabled, }: ComponentCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/ComponentCard/ComponentIcon/ComponentIcon.d.ts

@@ -0,0 +1,7 @@
+import { COMPONENT_ICONS } from '../../IconPicker/constants';
+interface ComponentIconProps {
+    isActive?: boolean;
+    icon?: keyof typeof COMPONENT_ICONS;
+}
+export declare const ComponentIcon: ({ isActive, icon }: ComponentIconProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/ComponentCard/ComponentIcon/index.d.ts

@@ -0,0 +1 @@
+export * from './ComponentIcon';

package/dist/admin/src/components/ComponentCard/index.d.ts

@@ -0,0 +1 @@
+export * from './ComponentCard';

package/dist/admin/src/components/ComponentList.d.ts

@@ -0,0 +1,8 @@
+import type { UID } from '@strapi/types';
+interface ComponentListProps {
+    component: UID.Component;
+    firstLoopComponentUid?: UID.Component | null;
+    isFromDynamicZone?: boolean;
+}
+export declare const ComponentList: ({ component, isFromDynamicZone, firstLoopComponentUid, }: ComponentListProps) => import("react/jsx-runtime").JSX.Element | undefined;
+export {};

package/dist/admin/src/components/ComponentRow.d.ts

@@ -0,0 +1,19 @@
+export declare const ComponentRow: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
+    children?: React.ReactNode;
+} & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+    ref?: any;
+}, "ref"> & {
+    ref?: any;
+}, "$isFromDynamicZone" | "$isChildOfDynamicZone"> & {
+    $isFromDynamicZone?: boolean;
+    $isChildOfDynamicZone?: boolean;
+}, never> & Partial<Pick<import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
+    children?: React.ReactNode;
+} & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+    ref?: any;
+}, "ref"> & {
+    ref?: any;
+}, "$isFromDynamicZone" | "$isChildOfDynamicZone"> & {
+    $isFromDynamicZone?: boolean;
+    $isChildOfDynamicZone?: boolean;
+}, never>>> & string & Omit<import("@strapi/design-system").BoxComponent<"div">, keyof import("react").Component<any, {}, any>>;

package/dist/admin/src/components/ContentTypeBuilderNav/ContentTypeBuilderNav.d.ts

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

package/dist/admin/src/components/ContentTypeBuilderNav/useContentTypeBuilderMenu.d.ts

@@ -0,0 +1,36 @@
+import type { Status } from '../../types';
+type Link = {
+    name: string;
+    to: string;
+    status: Status;
+    title: string;
+};
+type SubSection = {
+    name: string;
+    title: string;
+    links: Link[];
+};
+type MenuSection = {
+    name: string;
+    title: {
+        id: string;
+        defaultMessage: string;
+    };
+    customLink?: {
+        id: string;
+        defaultMessage: string;
+        onClick: () => void;
+    };
+    links: Array<SubSection | Link>;
+    linksCount?: number;
+};
+type Menu = MenuSection[];
+export declare const useContentTypeBuilderMenu: () => {
+    menu: Menu;
+    search: {
+        value: string;
+        onChange: import("react").Dispatch<import("react").SetStateAction<string>>;
+        clear: () => void;
+    };
+};
+export {};

package/dist/admin/src/components/ContentTypeRadioGroup.d.ts

@@ -0,0 +1,16 @@
+import type { ChangeEventHandler } from 'react';
+import type { IntlLabel } from '../types';
+interface Radio {
+    title: IntlLabel;
+    description: IntlLabel;
+    value: string | boolean;
+}
+interface ContentTypeRadioGroupProps {
+    intlLabel: IntlLabel;
+    name: string;
+    onChange: ChangeEventHandler<HTMLInputElement>;
+    radios?: Radio[];
+    value?: string | boolean;
+}
+export declare const ContentTypeRadioGroup: ({ onChange, ...rest }: ContentTypeRadioGroupProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/CustomRadioGroup/CustomRadioGroup.d.ts

@@ -0,0 +1,16 @@
+import type { ChangeEventHandler } from 'react';
+import type { IntlLabel } from '../../types';
+interface Radio {
+    title: IntlLabel;
+    description: IntlLabel;
+    value: string | boolean;
+}
+interface CustomRadioGroupProps {
+    intlLabel: IntlLabel;
+    name: string;
+    onChange: ChangeEventHandler<HTMLInputElement>;
+    radios?: Radio[];
+    value?: string | boolean;
+}
+export declare const CustomRadioGroup: ({ intlLabel, name, onChange, radios, value, }: CustomRadioGroupProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/CustomRadioGroup/Styles.d.ts

@@ -0,0 +1,6 @@
+declare const Wrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
+}, never> & Partial<Pick<Omit<Omit<import("@strapi/design-system").FlexProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
+}, never>>> & string & Omit<(<C extends React.ElementType<any, keyof React.JSX.IntrinsicElements> = "div">(props: React.PropsWithoutRef<import("@strapi/design-system").FlexProps<C>> & React.RefAttributes<unknown>) => React.ReactNode), keyof import("react").Component<any, {}, any>>;
+export { Wrapper };

package/dist/admin/src/components/CustomRadioGroup/index.d.ts

@@ -0,0 +1 @@
+export * from './CustomRadioGroup';

package/dist/admin/src/components/DataManager/DataManagerContext.d.ts

@@ -0,0 +1,139 @@
+import type { Component, ContentType } from '../../types';
+import type { ComponentWithChildren } from './utils/retrieveComponentsThatHaveComponents';
+import type { NestedComponent } from './utils/retrieveNestedComponents';
+import type { Internal, Struct } from '@strapi/types';
+export interface DataManagerContextValue {
+    isLoading: boolean;
+    addAttribute: (opts: {
+        attributeToSet: Record<string, unknown>;
+        forTarget: Struct.ModelType;
+        targetUid: Internal.UID.Schema;
+    }) => void;
+    editAttribute: (opts: {
+        attributeToSet: Record<string, unknown>;
+        forTarget: Struct.ModelType;
+        targetUid: Internal.UID.Schema;
+        name: string;
+    }) => void;
+    moveAttribute: (opts: {
+        forTarget: Struct.ModelType;
+        targetUid: Internal.UID.Schema;
+        from: number;
+        to: number;
+    }) => void;
+    addCustomFieldAttribute: (params: {
+        attributeToSet: Record<string, unknown>;
+        forTarget: Struct.ModelType;
+        targetUid: Internal.UID.Schema;
+    }) => void;
+    editCustomFieldAttribute: (params: {
+        attributeToSet: Record<string, unknown>;
+        forTarget: Struct.ModelType;
+        targetUid: Internal.UID.Schema;
+        name: string;
+    }) => void;
+    addCreatedComponentToDynamicZone: (opts: {
+        forTarget: Struct.ModelType;
+        targetUid: Internal.UID.Schema;
+        dynamicZoneTarget: string;
+        componentsToAdd: Internal.UID.Component[];
+    }) => void;
+    createComponentSchema: (opts: {
+        data: {
+            icon?: string;
+            displayName: string;
+        };
+        componentCategory: string;
+        uid: Internal.UID.Component;
+    }) => void;
+    createSchema: (opts: {
+        data: {
+            displayName: string;
+            singularName: string;
+            pluralName: string;
+            kind: Struct.ContentTypeKind;
+            draftAndPublish: boolean;
+            pluginOptions: Record<string, unknown>;
+        };
+        uid: Internal.UID.Schema;
+    }) => void;
+    changeDynamicZoneComponents: (opts: {
+        forTarget: Struct.ModelType;
+        targetUid: Internal.UID.Schema;
+        dynamicZoneTarget: string;
+        newComponents: Internal.UID.Component[];
+    }) => void;
+    removeAttribute: (opts: {
+        forTarget: Struct.ModelType;
+        targetUid: Internal.UID.Schema;
+        attributeToRemoveName: string;
+    }) => void;
+    deleteComponent(uid: Internal.UID.Component): void;
+    deleteContentType(uid: Internal.UID.ContentType): void;
+    removeComponentFromDynamicZone: (opts: {
+        forTarget: Struct.ModelType;
+        targetUid: Internal.UID.Schema;
+        dzName: string;
+        componentToRemoveIndex: number;
+    }) => void;
+    sortedContentTypesList: {
+        visible: ContentType['visible'];
+        name: ContentType['uid'];
+        title: ContentType['info']['displayName'];
+        plugin: ContentType['plugin'];
+        uid: ContentType['uid'];
+        to: string;
+        kind: ContentType['kind'];
+        restrictRelationsTo: ContentType['restrictRelationsTo'];
+        status: ContentType['status'];
+    }[];
+    updateComponentSchema: (opts: {
+        data: {
+            icon?: string;
+            displayName: string;
+        };
+        componentUID: Internal.UID.Component;
+    }) => void;
+    updateComponentUid: (opts: {
+        newComponentUID: Internal.UID.Component;
+        componentUID: Internal.UID.Component;
+    }) => void;
+    updateSchema: (opts: {
+        data: {
+            displayName: string;
+            kind: Struct.ContentTypeKind;
+            draftAndPublish: boolean;
+            pluginOptions: Record<string, unknown>;
+        };
+        uid: Internal.UID.ContentType;
+    }) => void;
+    initialComponents: Record<Internal.UID.Component, Component>;
+    components: Record<Internal.UID.Component, Component>;
+    componentsGroupedByCategory: Record<string, Component[]>;
+    componentsThatHaveOtherComponentInTheirAttributes: ComponentWithChildren[];
+    initialContentTypes: Record<Internal.UID.ContentType, ContentType>;
+    contentTypes: Record<Internal.UID.ContentType, ContentType>;
+    isInDevelopmentMode?: boolean;
+    nestedComponents: NestedComponent[];
+    reservedNames: {
+        models: string[];
+        attributes: string[];
+    };
+    allComponentsCategories: string[];
+    saveSchema(): Promise<void>;
+    isModified: boolean;
+    isSaving: boolean;
+    applyChange: (opts: {
+        action: 'add' | 'update' | 'delete';
+        schema: ContentType | Component;
+    }) => void;
+    history: {
+        undo(): void;
+        redo(): void;
+        discardAllChanges(): void;
+        canUndo: boolean;
+        canRedo: boolean;
+        canDiscardAll: boolean;
+    };
+}
+export declare const DataManagerContext: import("react").Context<DataManagerContextValue>;

package/dist/admin/src/components/DataManager/DataManagerProvider.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+interface DataManagerProviderProps {
+    children: React.ReactNode;
+}
+declare const DataManagerProvider: ({ children }: DataManagerProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default DataManagerProvider;