@zealicsolutions/web-ui 1.0.118 → 1.0.120

package/dist/cjs/containers/types/types.d.ts

@@ -0,0 +1,163 @@
+import { CSSObject } from '@emotion/react';
+import { CSSProperties, PropsWithChildren } from 'react';
+import { ValidationMode } from 'react-hook-form';
+import { SizesTypes } from 'theme';
+import type { AnyObject, Nullable, StylesType } from 'typescript';
+import { Molecule } from './moleculeTypes';
+export type ContainerType = 'default' | 'row' | 'column' | 'slider' | 'form' | 'form_purpose' | 'form_step' | 'dynamic' | 'journey_driven' | 'journey_driven_step' | 'replicator';
+export type ContainerTemplateType = 'row_content_container';
+export type WrappedContainerType = Extract<ContainerType, 'form' | 'form_step' | 'replicator'>;
+export type DmfId = string;
+export type ContainerPositionType = 'fixed' | 'sticky' | 'static' | 'relative';
+export type ContainerAlignItemsType = 'start' | 'center' | 'end' | 'stretch';
+export type ContainerScrollBehaviourType = 'vertical' | 'horizontal' | 'auto' | 'none';
+export type StateActionType = 'visible' | 'disabled';
+export type StateEventType = 'click' | 'view';
+export type StateListenerConfigType = {
+    role: 'stateListener';
+    stateKey: string;
+    stateValue: string | boolean;
+    defaultState: Partial<Record<StateActionType, boolean>>;
+    action: Partial<Record<StateActionType, boolean>>;
+};
+export type StateModifierConfigType = {
+    role: 'stateModifier';
+    stateKey: string;
+    event: StateEventType;
+};
+export type MetadataStateConfig = StateListenerConfigType | StateModifierConfigType;
+export type MetadataType = AnyObject & Partial<{
+    stateConfig: MetadataStateConfig[];
+    referenceName: string;
+    isAction: boolean;
+    isTrigger: boolean;
+    notEditable: boolean;
+    hasOwnButton: boolean;
+    stateListenerId: string;
+    configurationPath: string;
+}>;
+export type SliderProps = {
+    autoplay?: boolean;
+    autoplayDuration?: number;
+};
+export type FormStepContainerProps = {
+    formStepName: string;
+    order: number;
+    conditionConfig: ConditionConfig;
+    formStepStyles?: CSSProperties;
+};
+export type FormContainerProps = {
+    mode: keyof ValidationMode;
+};
+export type PaddingVariants = 'top' | 'right' | 'bottom' | 'left';
+export type Padding = Record<PaddingVariants, SizesTypes | number> | SizesTypes | string;
+export type ContainerProperties = {
+    backgroundImage: {
+        imageFile: {
+            url: string;
+        };
+    };
+    enableBackgroundImage: {
+        value: boolean;
+    };
+};
+export type ContainerPropsType = Partial<{
+    position: ContainerPositionType;
+    alignItems: ContainerAlignItemsType;
+    scrollBehaviour: ContainerScrollBehaviourType;
+    cornerRadius: SizesTypes | number;
+    gap: SizesTypes;
+    styles: StylesType;
+    paddingTop: SizesTypes;
+    paddingBottom: SizesTypes;
+    paddingLeft: SizesTypes;
+    paddingRight: SizesTypes;
+    autoplay: boolean;
+    autoplayDuration: number;
+    formProps: FormContainerProps;
+    formStepProps: FormStepContainerProps;
+    border: string;
+    activeChildrenIds: string[];
+    activeOrganismIds: string[];
+    padding: Padding;
+    enableBackgroundImage: boolean;
+    dataModelFieldId?: DmfId;
+}>;
+export type AdditionalContainerProps = Partial<{
+    containerStyle: CSSObject;
+    containerProps: ContainerPropsType;
+}>;
+export type ContainerConfig = {
+    props: ContainerPropsType;
+    wide: AdditionalContainerProps;
+    compact: AdditionalContainerProps;
+};
+export type ContainerProps = PropsWithChildren<{
+    type: ContainerType;
+} & Partial<{
+    name: string;
+    config: ContainerConfig;
+    isMobile: boolean;
+    metadata: MetadataType;
+    properties: ContainerProperties;
+    containerTemplateType: ContainerTemplateType;
+}>>;
+export type ContainerComponentProps = {
+    id: string;
+    instance: 'container';
+    type: ContainerType;
+    dataModelFieldId?: DmfId;
+    items: (ContainerComponentProps | Molecule)[];
+    config: Partial<{
+        wide: AdditionalContainerProps;
+        compact: AdditionalContainerProps;
+        props: ContainerPropsType;
+    }>;
+    tabsProps?: {
+        tabs: unknown[];
+        activeTabKey: string;
+        onTabChange: () => void;
+    };
+    metadata?: MetadataType;
+    properties?: ContainerProperties;
+    containerLibraryId?: string;
+    isMobile?: boolean;
+    isConfigurationMode?: boolean;
+};
+export type CriteriaType = 'operator' | 'condition';
+export type ConditionCriteria = {
+    id: string;
+    type: CriteriaType;
+    operator: string;
+    dataFieldId: Nullable<string>;
+    subtypeId: Nullable<string>;
+    dataFieldName: Nullable<string>;
+    dataValue: Nullable<string>;
+    connectedTo: Nullable<string>;
+};
+export type SegmentationType = 'simple' | 'advanced';
+export type ConditionConfig = Nullable<{
+    id: string;
+    segmentationType: SegmentationType;
+    criteriaList: ConditionCriteria[];
+}>;
+export type FormDataStateConfig = {
+    value?: string | number;
+    id?: string | number;
+    label?: string;
+    code?: string;
+} & Record<string, {
+    value?: string | number;
+    id?: string | number;
+    label?: string;
+    code?: string;
+}>;
+export type ActionType = 'clicked' | 'started' | 'completed' | 'closed' | 'opened' | 'checked' | 'unchecked';
+export type ActionEventType = Record<'interacted', ActionType>;
+export type BaseStateValue = {
+    visible: boolean;
+    disabled: boolean;
+};
+export type StateConfigType = {
+    [stateKey: string]: null | string | boolean | FormDataStateConfig | ActionEventType | BaseStateValue;
+};

package/dist/cjs/containers/utils/dataPathUtils.d.ts

@@ -0,0 +1,9 @@
+import { PathSegment } from '../../contexts/ContainerRuntimeContext/types';
+/**
+ * Navigate through id-keyed data structure using path segments
+ */
+export declare const getDataByPath: (data: Record<string, unknown> | null | undefined, segments: PathSegment[]) => Record<string, unknown> | null;
+/**
+ * Create a stable key for React rendering based on path segments
+ */
+export declare const createPathKey: (segments: PathSegment[]) => string;

package/dist/cjs/containers/utils/dataPathUtils.test.d.ts

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

package/dist/cjs/containers/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function overrideProperties(savedProperties: Partial<Record<string, unknown>>, currentContentProperties: Partial<Record<string, unknown>> | undefined, propertyKeys: string[], // Renamed to avoid conflict
+selected: boolean): Partial<Record<string, unknown>>;
+export declare function overrideProps(savedProps: Partial<Record<string, unknown>>, currentStyleProperties?: Partial<Record<string, unknown>>, selected?: boolean): Partial<Record<string, unknown>>;

package/dist/cjs/contexts/AccountButtonContext/AccountButtonContext.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import type { Callback } from 'typescript';
+export type AccountButtonContextType = Partial<{
+    userInitials: string;
+    logOutHandler: Callback;
+    goToAccountInfo: Callback;
+    username: string;
+}>;
+export declare const AccountButtonContext: import("react").Context<Partial<{
+    userInitials: string;
+    logOutHandler: Callback;
+    goToAccountInfo: Callback;
+    username: string;
+}>>;

package/dist/cjs/contexts/AccountButtonContext/AccountButtonContextProvider.d.ts

@@ -0,0 +1,9 @@
+import { PropsWithChildren } from 'react';
+import type { Callback } from 'typescript';
+export type AccountButtonProviderProps = PropsWithChildren<Partial<{
+    userInitials: string;
+    logOutHandler: Callback;
+    goToAccountInfo: Callback;
+    username: string;
+}>>;
+export declare const AccountButtonProvider: ({ children, goToAccountInfo, userInitials, logOutHandler, username, }: AccountButtonProviderProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/cjs/contexts/AccountButtonContext/useAccountButtonContext.d.ts

@@ -0,0 +1,6 @@
+export declare const useAccountButtonContext: () => Partial<{
+    userInitials: string;
+    logOutHandler: import("../../typescript").Callback;
+    goToAccountInfo: import("../../typescript").Callback;
+    username: string;
+}>;

package/dist/cjs/contexts/ApiContext/ApiContext.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="react" />
+import type { AxiosResponse } from 'axios';
+import type { DataGridPage, DataGridQuery } from 'organisms';
+import type { AnyObject, ResponseDTO } from 'typescript';
+export declare enum CalendarEventType {
+    EVENT = "event",
+    RESOURCE = "resource",
+    OVERLAY = "overlay"
+}
+export interface Option {
+    id: string;
+    label: string;
+}
+export type RuntimeApiResponseDTO<T> = Promise<AxiosResponse<ResponseDTO<T>>>;
+export interface ApiInterface {
+    pickList: {
+        get(dataModelFieldId?: string): RuntimeApiResponseDTO<Option[]> | Promise<AxiosResponse<Option[]>>;
+    };
+    forms?: {
+        submit: (payload: AnyObject) => Promise<unknown>;
+    };
+    dataGrid?: {
+        getOrganismData: (organismId: string, body: DataGridQuery) => RuntimeApiResponseDTO<{
+            viewType: 'data_grid';
+            data: DataGridPage;
+        }>;
+    };
+    calendar?: {
+        createEvent: (payload: AnyObject) => Promise<CalendarEventType | void>;
+        updateEvent: (payload: AnyObject) => Promise<CalendarEventType | void>;
+        deleteEvent: (recordId: string) => Promise<void>;
+        getOrganismData: (organismId: string, body: {
+            start: Date;
+            end: Date;
+        }) => RuntimeApiResponseDTO<{
+            viewType: 'calendar';
+            data: {
+                events: CalendarEventType[];
+                resources: Array<AnyObject>;
+                overlays?: Array<AnyObject>;
+            };
+        }>;
+    };
+}
+export declare const ApiContext: import("react").Context<ApiInterface>;

package/dist/cjs/contexts/ApiContext/ApiProvider.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { ApiInterface } from './ApiContext';
+export declare const ApiProvider: ({ api, children }: {
+    api: ApiInterface;
+    children: ReactNode;
+}) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/cjs/contexts/ApiContext/globalQueries/form/useSubmitForm.d.ts

@@ -0,0 +1,5 @@
+export type SubmitFormPayload = Record<string, unknown>;
+export declare const useSubmitForm: () => {
+    submitForm: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<unknown, Error, SubmitFormPayload, unknown>;
+    isLoading: boolean;
+};

package/dist/cjs/contexts/ApiContext/globalQueries/index.d.ts

@@ -0,0 +1,2 @@
+export { useSubmitForm } from './form/useSubmitForm';
+export { usePickListOptions } from './pickList/usePickListOptions';

package/dist/cjs/contexts/ApiContext/globalQueries/pickList/usePickListOptions.d.ts

@@ -0,0 +1,5 @@
+export declare const usePickListOptions: (dataModelFieldId?: string) => {
+    dataModelFieldOptions: any;
+    refetch: (options?: import("@tanstack/query-core/build/legacy/hydration-BlEK5ylC").al | undefined) => Promise<import("@tanstack/query-core/build/legacy/hydration-BlEK5ylC").aC<any, Error>>;
+    isLoading: false;
+};

package/dist/cjs/contexts/ApiContext/globalQueries/queryKeys.d.ts

@@ -0,0 +1,6 @@
+export declare const queryKeys: {
+    readonly getPickListOptions: "getPickListOptions";
+    readonly getCalendarEvents: "getCalendarEvents";
+    readonly getDataGridRows: "getDataGridRows";
+    readonly sendFormData: "sendFormData";
+};

package/dist/cjs/contexts/ApiContext/useApi.d.ts

@@ -0,0 +1,2 @@
+import { ApiInterface } from './ApiContext';
+export declare const useApi: () => ApiInterface;

package/dist/cjs/contexts/ButtonActionsContext/ButtonActionsContext.d.ts

@@ -0,0 +1,13 @@
+import { ContainerComponentProps } from 'containers';
+import { Dispatch, SetStateAction } from 'react';
+export type ButtonActionsContextType = {
+    actionContent?: ContainerComponentProps;
+    setActionContent: Dispatch<SetStateAction<ContainerComponentProps>>;
+    isModalVisible: boolean;
+    isDrawerVisible: boolean;
+    setDrawerVisible: Dispatch<SetStateAction<boolean>>;
+    setActivePopUpById: (id: string) => void;
+    onCloseModal: (id?: string) => void;
+    onCloseDrawer: () => void;
+};
+export declare const ButtonActionsContext: import("react").Context<ButtonActionsContextType>;

package/dist/cjs/contexts/ButtonActionsContext/ButtonActionsContextProvider.d.ts

@@ -0,0 +1,26 @@
+import { ContainerComponentProps, Molecule } from 'containers';
+import { Dispatch, PropsWithChildren, SetStateAction } from 'react';
+import { AnyObject } from 'typescript';
+export type PopupPropsType = {
+    id: string;
+    config: {
+        styles?: AnyObject;
+        size?: 'large' | 'medium';
+        withCloseIcon?: boolean;
+    };
+    content: {
+        embedded?: (ContainerComponentProps | Molecule)[];
+        isi?: ContainerComponentProps | Molecule;
+    };
+};
+export type ButtonActionsProviderProps = PropsWithChildren<Partial<{
+    actionContent: ContainerComponentProps;
+    setActionContent: Dispatch<SetStateAction<ContainerComponentProps>>;
+    isModalVisible: boolean;
+    setDrawerVisible: Dispatch<SetStateAction<boolean>>;
+    isDrawerVisible: boolean;
+    setActivePopUpById: (id: string) => void;
+    onCloseModal: (id: string) => void;
+    popupProps?: PopupPropsType[];
+}>>;
+export declare const ButtonActionsProvider: ({ children, popupProps }: ButtonActionsProviderProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/cjs/contexts/ButtonActionsContext/useButtonActionsContext.d.ts

@@ -0,0 +1 @@
+export declare const useButtonActionsContext: () => import("./ButtonActionsContext").ButtonActionsContextType;

package/dist/cjs/contexts/ContainerRuntimeContext/ContainerRuntimeContext.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { ContainerRuntimeContextValue } from './types';
+export declare const ContainerRuntimeContext: import("react").Context<ContainerRuntimeContextValue | null>;
+export declare const useContainerRuntime: () => ContainerRuntimeContextValue & {
+    getDmfValue: (dmfId: string) => unknown;
+};

package/dist/cjs/contexts/ContainerRuntimeContext/ContainerRuntimeContextProvider.d.ts

@@ -0,0 +1,3 @@
+import { FC, PropsWithChildren } from 'react';
+import { ContainerRuntimeContextProviderProps } from './types';
+export declare const ContainerRuntimeContextProvider: FC<PropsWithChildren<ContainerRuntimeContextProviderProps>>;

package/dist/cjs/contexts/ContainerRuntimeContext/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ContainerRuntimeContext';
+export * from './ContainerRuntimeContextProvider';
+export * from './types';

package/dist/cjs/contexts/ContainerRuntimeContext/types.d.ts

@@ -0,0 +1,14 @@
+export type DmfId = string;
+export type PathSegment = {
+    dmfId: DmfId;
+    index?: number;
+};
+export type ContainerRuntimeContextValue = {
+    containerId: string;
+    nestedPathSegments: PathSegment[];
+    itemIndex?: number;
+    itemDataByDmfId?: Record<string, unknown>;
+};
+export type ContainerRuntimeContextProviderProps = {
+    value: ContainerRuntimeContextValue;
+};

package/dist/cjs/contexts/FormStepContext/FormStepContext.d.ts

@@ -0,0 +1,13 @@
+import { Dispatch, SetStateAction } from 'react';
+export type FormStepContextType = {
+    steps: number;
+    currentStep: number;
+    goToNextStep: () => void;
+    goToPrevStep: () => void;
+    reset: () => void;
+    canGoToNextStep: boolean;
+    canGoToPrevStep: boolean;
+    setStep: Dispatch<SetStateAction<number>>;
+    setInitSteps: Dispatch<SetStateAction<number>>;
+};
+export declare const FormStepContext: import("react").Context<FormStepContextType>;

package/dist/cjs/contexts/FormStepContext/FormStepContextProvider.d.ts

@@ -0,0 +1,5 @@
+import { PropsWithChildren } from 'react';
+export type FormStepContextProviderProps = PropsWithChildren<{
+    initialStepsCount?: number;
+}>;
+export declare const FormStepContextProvider: ({ initialStepsCount, children, }: FormStepContextProviderProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/cjs/contexts/FormStepContext/useFormStepContext.d.ts

@@ -0,0 +1 @@
+export declare const useFormStepContext: () => import("./FormStepContext").FormStepContextType;

package/dist/cjs/contexts/FormStepContext/utils.d.ts

@@ -0,0 +1,2 @@
+import { ContainerComponentProps } from 'containers';
+export declare const getFormStepContainers: (items: ContainerComponentProps[]) => ContainerComponentProps[];

package/dist/cjs/contexts/LayoutContext/LayoutContext.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+export interface DrawerState {
+    width: number;
+    position: 'left' | 'right' | 'top' | 'bottom';
+    isOpen: boolean;
+    positionType?: 'absolute' | 'normal';
+}
+export interface LayoutContextType {
+    drawer: DrawerState;
+    updateDrawer: (props: Partial<DrawerState>) => void;
+    drawerContainerRef?: Element | null;
+    setDrawerContainerRef?: (ref: Element | null) => void;
+    headerHeight?: string;
+    setHeaderHeight?: (height: string) => void;
+    isMobile?: boolean;
+    isMLR?: boolean;
+}
+export declare const LayoutContext: import("react").Context<LayoutContextType>;

package/dist/cjs/contexts/LayoutContext/LayoutContextProvider.d.ts

@@ -0,0 +1,9 @@
+import React, { PropsWithChildren } from 'react';
+export interface LayoutProviderProps extends PropsWithChildren {
+    layoutPosition?: 'normal' | 'absolute';
+    headerHeight?: string;
+    drawerMaxWidthPercent?: number;
+    isMLR?: boolean;
+    isMobile?: boolean;
+}
+export declare const LayoutProvider: React.FC<LayoutProviderProps>;

package/dist/cjs/contexts/LayoutContext/useLayoutContext.d.ts

@@ -0,0 +1 @@
+export declare const useLayoutContext: () => import("./LayoutContext").LayoutContextType;

package/dist/cjs/contexts/MlrRichTextViewerContext/MlrRichTextViewerContext.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { AnnotationsList } from 'contexts/MlrRichTextViewerContext/types';
+export type MlrRichTextViewerContextType = {
+    isMLRReview: boolean;
+    showAnnotations: boolean;
+    annotationsList: AnnotationsList;
+};
+export declare const MlrRichTextViewerContext: import("react").Context<MlrRichTextViewerContextType>;

package/dist/cjs/contexts/MlrRichTextViewerContext/MlrRichTextViewerProvider.d.ts

@@ -0,0 +1,8 @@
+import { AnnotationsList } from 'contexts/MlrRichTextViewerContext/types';
+import { PropsWithChildren } from 'react';
+export type MlrRichTextViewerProviderProps = PropsWithChildren<{
+    annotationsList: AnnotationsList;
+    isMLRReview: boolean;
+    showAnnotations: boolean;
+}>;
+export declare const MlrRichTextViewerProvider: ({ children, isMLRReview, showAnnotations, annotationsList, }: MlrRichTextViewerProviderProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/cjs/contexts/MlrRichTextViewerContext/types.d.ts

@@ -0,0 +1,15 @@
+export type AnnotationsList = {
+    tags: {
+        id: string;
+        label: string;
+        entityIds: string[];
+        moleculeIds: string[];
+        referencedByIds: string[];
+    }[];
+    links: {
+        referencedById: string;
+        moleculeId: string;
+        text: string;
+        url: string;
+    }[];
+};

package/dist/cjs/contexts/MlrRichTextViewerContext/useMlrRichTextViewerContext.d.ts

@@ -0,0 +1 @@
+export declare const useMlrRichTextViewerContext: () => import("./MlrRichTextViewerContext").MlrRichTextViewerContextType;

package/dist/cjs/contexts/OrganismContext/OrganismContext.d.ts

@@ -0,0 +1,65 @@
+import { ContainerComponentProps, MetadataType, Molecule, StateConfigType } from 'containers';
+import { PasswordRuleValidation } from 'molecules/PasswordSetup/PasswordSetup';
+import { Dispatch, SetStateAction } from 'react';
+import type { AnyObject } from 'typescript';
+import { ConfigurationItem } from './OrganismContextProvider';
+import { GroupedStepItemsByStepContainer } from './utils';
+export type OrganismContextType = {
+    items: (ContainerComponentProps | Molecule)[];
+    groupStepItemsByStepContainer: () => GroupedStepItemsByStepContainer;
+    dateFields: {
+        id: string;
+        dateType: string;
+    }[];
+    setDateFields: Dispatch<SetStateAction<{
+        id: string;
+        dateType: string;
+    }[]>>;
+    formId?: string;
+    isPreview?: boolean;
+    submitHandler?: (data: {
+        formId: string;
+        data: AnyObject;
+    }) => Promise<void>;
+    validations?: PasswordRuleValidation[];
+    editable?: boolean;
+    organismBodyId?: string;
+    isFormInEditMode?: boolean;
+    isConfigurationMode?: boolean;
+    localStateObject?: StateConfigType | null;
+    localState?: Record<string, unknown>;
+    setLocalStateValue?: (key: string, value: unknown) => void;
+    organismMetadata?: MetadataType;
+    organismInfo?: AnyObject;
+    onConfigurationItemClicked: (itemInfo: Omit<ConfigurationItem, 'organismId'>, doubleClick: boolean) => void;
+    selectedConfigurationItemId?: string;
+    currentStyleProperties: Record<string, string>;
+    currentContentProperties: Record<string, string>;
+    onInternalNavigation: (args: {
+        link: string;
+        state?: Record<string, unknown>;
+        query?: Record<string, string | number | boolean | undefined>;
+    }) => void;
+    /**
+     * Host-provided routing info for runtime behaviors (URL → organism).
+     * If provided, `organismIdFromUrl` must equal `formId` for form runtime
+     * behaviors (prefill/edit) to execute.
+     */
+    routing?: {
+        organismIdFromUrl?: string;
+        rwoRecordIdFromUrl?: string;
+    };
+    /**
+     * Prefill payload passed via navigation state. Keys must follow
+     * "pmi-object-id.data-model-field-id" and will be fed to react-hook-form reset().
+     */
+    prefillData?: Record<string, unknown> | null;
+    /**
+     * Host-supplied loader to fetch a record's data by recordId for edit mode.
+     * Must resolve to the flat object keyed by "pmi-object-id.data-model-field-id".
+     */
+    loadRecordData?: (args: {
+        rwoRecordId: string;
+    }) => Promise<Record<string, unknown>>;
+};
+export declare const OrganismContext: import("react").Context<OrganismContextType>;

package/dist/cjs/contexts/OrganismContext/OrganismContextProvider.d.ts

@@ -0,0 +1,56 @@
+import { ContainerComponentProps, ContainerType, Molecule, MoleculeItemTypes, MoleculeTypes, StateConfigType } from 'containers';
+import { PasswordRuleValidation } from 'molecules';
+import React from 'react';
+import type { AnyObject } from 'typescript';
+export type ConfigurationItem = {
+    entity: 'container' | 'molecule' | 'molecule_item';
+    entityId: string;
+    organismInfo?: AnyObject;
+    entityName?: string;
+    entityType: ContainerType | MoleculeTypes | MoleculeItemTypes;
+    organismLibraryMoleculeId?: string;
+    /**
+     * Generic library entity identifier to be used by host apps
+     * for backend lookups (e.g., fetching Data Model Fields by libraryMoleculeId).
+     * For molecules, this mirrors organismLibraryMoleculeId.
+     */
+    libraryEntityId?: string;
+};
+export type OrganismContextProviderProps = React.PropsWithChildren<{} & Partial<{
+    formId: string;
+    editable: boolean;
+    isPreview: boolean;
+    initItems: (ContainerComponentProps | Molecule)[];
+    localStateObject: StateConfigType | null;
+    validations: PasswordRuleValidation[];
+    submitHandler: (data: {
+        formId: string;
+        data: AnyObject;
+    }) => Promise<void>;
+    organismBodyId: string;
+    isFormInEditMode: boolean;
+    organismMetadata: AnyObject;
+    organismInfo: AnyObject;
+    isConfigurationMode: boolean;
+    onConfigurationItemHandler: (itemInfo: ConfigurationItem, doubleClick: boolean) => void;
+    selectedConfigurationItemId: string;
+    currentStyleProperties: Record<string, string>;
+    currentContentProperties: Record<string, string>;
+    onInternalNavigation: (args: {
+        link: string;
+        state?: Record<string, unknown>;
+        query?: Record<string, string | number | boolean | undefined>;
+    }) => void;
+    /** Host-provided routing info (URL → organism) */
+    routing: {
+        organismIdFromUrl?: string;
+        rwoRecordIdFromUrl?: string;
+    };
+    /** Prefill payload from navigation state */
+    prefillData: Record<string, unknown> | null;
+    /** Loader for edit mode */
+    loadRecordData: (args: {
+        rwoRecordId: string;
+    }) => Promise<Record<string, unknown>>;
+}>>;
+export declare const OrganismContextProvider: ({ initItems, children, submitHandler, formId, validations, editable, isPreview, organismBodyId, isFormInEditMode, organismMetadata, organismInfo, localStateObject, isConfigurationMode, onConfigurationItemHandler, selectedConfigurationItemId, currentStyleProperties, currentContentProperties, onInternalNavigation, routing, prefillData, loadRecordData, }: OrganismContextProviderProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/cjs/contexts/OrganismContext/useOrganismContext.d.ts

@@ -0,0 +1 @@
+export declare const useOrganismContext: () => import("./OrganismContext").OrganismContextType;

package/dist/cjs/contexts/OrganismContext/utils.d.ts

@@ -0,0 +1,5 @@
+import { ContainerComponentProps, Molecule } from 'containers';
+type StepItem = ContainerComponentProps | Molecule;
+export type GroupedStepItemsByStepContainer = Map<string, StepItem[]>;
+export declare const groupStepItemsByStepContainer: (items: StepItem[]) => GroupedStepItemsByStepContainer;
+export {};

package/dist/cjs/contexts/StateContext/StateContext.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { StateConfigType } from 'containers';
+export type StateContextType = {
+    stateConfig: StateConfigType;
+    stateHandler?: (updatedStateConfig: StateConfigType) => void;
+    authenticated: boolean;
+};
+export declare const StateContext: import("react").Context<StateContextType>;

package/dist/cjs/contexts/StateContext/StateContextProvider.d.ts

@@ -0,0 +1,8 @@
+import { StateConfigType } from 'containers';
+import { PropsWithChildren } from 'react';
+export type StateContextProviderProps = PropsWithChildren<{
+    initStateConfig: StateConfigType;
+    stateHandler?: (updatedStateConfig: StateConfigType) => void;
+    authenticated: boolean;
+}>;
+export declare const StateContextProvider: ({ initStateConfig, children, stateHandler, authenticated, }: StateContextProviderProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/cjs/contexts/StateContext/useStateContext.d.ts

@@ -0,0 +1 @@
+export declare const useStateContext: () => import("./StateContext").StateContextType;