@wix/headless-forms 0.0.2 → 0.0.3

package/dist/react/Form.js

@@ -1,13 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import React, { useCallback, useState } from 'react';
+import React, { useState, useCallback } from 'react';
 import { AsChildSlot } from '@wix/headless-utils/react';
-import { useService } from '@wix/services-manager-react';
 import { Form as FormViewer, } from '@wix/form-public';
-import { FormServiceDefinition, } from '../services/form-service';
-import * as CoreForm from './core/Form';
+import { Root as CoreRoot, Loading as CoreLoading, LoadingError as CoreLoadingError, Error as CoreError, Submitted as CoreSubmitted, Fields as CoreFields, } from './core/Form';
 var TestIds;
 (function (TestIds) {
     TestIds["formRoot"] = "form-root";
+    TestIds["form"] = "form";
+    TestIds["formLoading"] = "form-loading";
     TestIds["formLoadingError"] = "form-loading-error";
     TestIds["formError"] = "form-error";
     TestIds["formSubmitted"] = "form-submitted";
@@ -21,6 +21,7 @@ var TestIds;
  * @param {RootProps} props - The component props
  * @param {React.ReactNode} props.children - Child components that will have access to form context
  * @param {FormServiceConfig} props.formServiceConfig - Form service configuration object
+ * @param {boolean} [props.asChild] - Whether to render as a child component
  * @param {string} [props.className] - CSS classes to apply to the root element
  * @example
  * ```tsx
@@ -63,7 +64,7 @@ var TestIds;
  */
 export const Root = React.forwardRef((props, ref) => {
     const { children, formServiceConfig, asChild, ...otherProps } = props;
-    return (_jsx(CoreForm.Root, { formServiceConfig: formServiceConfig, children: _jsx(RootContent, { asChild: asChild, ref: ref, ...otherProps, children: children }) }));
+    return (_jsx(CoreRoot, { formServiceConfig: formServiceConfig, children: _jsx(RootContent, { asChild: asChild, ref: ref, ...otherProps, children: children }) }));
 });
 /**
  * Internal component to handle the Root content with service access.
@@ -127,10 +128,10 @@ const RootContent = React.forwardRef((props, ref) => {
  */
 export const Loading = React.forwardRef((props, ref) => {
     const { asChild, children, className, ...otherProps } = props;
-    return (_jsx(CoreForm.Loading, { children: ({ isLoading }) => {
+    return (_jsx(CoreLoading, { children: ({ isLoading }) => {
             if (!isLoading)
                 return null;
-            return (_jsx(AsChildSlot, { ref: ref, asChild: asChild, className: className, "data-testid": "form-loading", customElement: children, content: "Loading form...", ...otherProps, children: _jsx("div", { children: "Loading form..." }) }));
+            return (_jsx(AsChildSlot, { "data-testid": TestIds.formLoading, ref: ref, asChild: asChild, className: className, customElement: children, content: "Loading form...", ...otherProps, children: _jsx("div", { children: "Loading form..." }) }));
         } }));
 });
 /**
@@ -184,7 +185,7 @@ export const Loading = React.forwardRef((props, ref) => {
  */
 export const LoadingError = React.forwardRef((props, ref) => {
     const { asChild, children, className, ...otherProps } = props;
-    return (_jsx(CoreForm.LoadingError, { children: ({ error, hasError }) => {
+    return (_jsx(CoreLoadingError, { children: ({ error, hasError }) => {
             if (!hasError)
                 return null;
             const errorData = { error, hasError };
@@ -240,7 +241,7 @@ export const LoadingError = React.forwardRef((props, ref) => {
  */
 export const Error = React.forwardRef((props, ref) => {
     const { asChild, children, className, ...otherProps } = props;
-    return (_jsx(CoreForm.Error, { children: ({ error, hasError }) => {
+    return (_jsx(CoreError, { children: ({ error, hasError }) => {
             if (!hasError)
                 return null;
             const errorData = { error, hasError };
@@ -296,7 +297,7 @@ export const Error = React.forwardRef((props, ref) => {
  */
 export const Submitted = React.forwardRef((props, ref) => {
     const { asChild, children, className, ...otherProps } = props;
-    return (_jsx(CoreForm.Submitted, { children: ({ isSubmitted, message }) => {
+    return (_jsx(CoreSubmitted, { children: ({ isSubmitted, message }) => {
             if (!isSubmitted)
                 return null;
             const submittedData = { isSubmitted, message };
@@ -447,14 +448,7 @@ export const Submitted = React.forwardRef((props, ref) => {
  * };
  * ```
  */
-export const Fields = React.forwardRef(({ fieldMap }, ref) => {
-    const formService = useService(FormServiceDefinition);
-    const form = formService.form.get();
-    const _form = {
-        ...form,
-        id: form?._id,
-        fields: form?.formFields?.map((field) => ({ ...field, id: field._id })),
-    };
+export const Fields = React.forwardRef((props, ref) => {
     const [formValues, setFormValues] = useState({});
     const [formErrors, setFormErrors] = useState([]);
     const handleFormChange = useCallback((values) => {
@@ -463,72 +457,17 @@ export const Fields = React.forwardRef(({ fieldMap }, ref) => {
     const handleFormValidate = useCallback((errors) => {
         setFormErrors(errors);
     }, []);
-    if (!form)
-        return _jsx("div", { children: "Form not found, oops!" });
-    return (_jsx("div", { ref: ref, children: _jsx(FormViewer, { form: _form, values: formValues, onChange: handleFormChange, errors: formErrors, onValidate: handleFormValidate, fields: fieldMap }) }));
+    return (_jsx(CoreFields, { children: ({ form }) => {
+            console.log('Fields form', form);
+            if (!form)
+                return null;
+            return (_jsx("div", { ref: ref, children: _jsx(FormViewer, { form: {
+                        ...form,
+                        id: form?._id,
+                        fields: form?.formFields?.map((field) => ({
+                            ...field,
+                            id: field._id,
+                        })),
+                    }, values: formValues, onChange: handleFormChange, errors: formErrors, onValidate: handleFormValidate, fields: props.fieldMap }) }));
+        } }));
 });
-/**
- * Main Form namespace containing all form components following the compound component pattern.
- * Provides a headless, flexible way to render and manage forms with custom field components.
- *
- * @namespace Form
- * @property {typeof Root} Root - Form root component that provides service context to all child components
- * @property {typeof Loading} Loading - Form loading state component that displays content during form loading
- * @property {typeof LoadingError} LoadingError - Form loading error state component for handling form loading errors
- * @property {typeof Error} Error - Form submit error state component for handling form submission errors
- * @property {typeof Submitted} Submitted - Form submitted state component for displaying success messages
- * @property {typeof Fields} Fields - Form fields component for rendering form fields with custom field renderers
- * @example
- * ```tsx
- * import { Form } from '@wix/headless-forms/react';
- * import { loadFormServiceConfig } from '@wix/headless-forms/services';
- * import { TextInput, TextArea, Checkbox } from './field-components';
- *
- * const FIELD_MAP = {
- *   TEXT_INPUT: TextInput,
- *   TEXT_AREA: TextArea,
- *   CHECKBOX: Checkbox,
- *   // ... other field components
- * };
- *
- * // Pattern 1: Pre-loaded form data (SSR/SSG)
- * function MyForm({ formServiceConfig }) {
- *   return (
- *     <Form.Root formServiceConfig={formServiceConfig}>
- *       <Form.Loading className="flex justify-center p-4" />
- *       <Form.LoadingError className="text-destructive px-4 py-3 rounded mb-4" />
- *       <Form.Fields fieldMap={FIELD_MAP} />
- *       <Form.Error className="text-destructive p-4 rounded-lg mb-4" />
- *       <Form.Submitted className="text-green-500 p-4 rounded-lg mb-4" />
- *     </Form.Root>
- *   );
- * }
- *
- * // Pattern 2: Lazy loading with formId (Client-side)
- * function DynamicForm({ formId }) {
- *   return (
- *     <Form.Root formServiceConfig={{ formId }}>
- *       <Form.Loading className="flex justify-center p-4" />
- *       <Form.LoadingError className="text-destructive px-4 py-3 rounded mb-4" />
- *       <Form.Fields fieldMap={FIELD_MAP} />
- *       <Form.Error className="text-destructive p-4 rounded-lg mb-4" />
- *       <Form.Submitted className="text-green-500 p-4 rounded-lg mb-4" />
- *     </Form.Root>
- *   );
- * }
- * ```
- */
-export const Form = {
-    /** Form root component that provides service context */
-    Root,
-    /** Form loading state component */
-    Loading,
-    /** Form loading error state component */
-    LoadingError,
-    /** Form error state component */
-    Error,
-    /** Form submitted state component */
-    Submitted,
-    /** Form fields component for rendering form fields */
-    Fields,
-};

package/dist/react/core/Form.d.ts

@@ -1,4 +1,8 @@
+import { forms } from '@wix/forms';
 import { FormServiceConfig } from '../../services/form-service.js';
+/**
+ * Props for Root headless component
+ */
 export interface RootProps {
     children: React.ReactNode;
     formServiceConfig: FormServiceConfig;
@@ -9,8 +13,9 @@ export interface RootProps {
  *
  * @order 1
  * @component
- * @param {React.ReactNode} children - Child components that will have access to form context
- * @param {FormServiceConfig} formServiceConfig - Configuration object containing form data
+ * @param {RootProps} props - Component props
+ * @param {React.ReactNode} props.children - Child components that will have access to form context
+ * @param {FormServiceConfig} props.formServiceConfig - Configuration object containing form data
  * @example
  * ```tsx
  * import { Form } from '@wix/headless-forms/react';
@@ -47,7 +52,7 @@ export interface RootProps {
  * }
  * ```
  */
-export declare function Root(props: RootProps): React.ReactNode;
+export declare function Root({ formServiceConfig, children, }: RootProps): React.ReactNode;
 /**
  * Props for FormLoading headless component
  */
@@ -213,3 +218,44 @@ export interface FormSubmittedRenderProps {
  * ```
  */
 export declare function Submitted(props: FormSubmittedProps): import("react").ReactNode;
+/**
+ * Render props for Fields component
+ */
+interface FieldsRenderProps {
+    form: forms.Form | null;
+}
+/**
+ * Props for Fields headless component
+ */
+interface FieldsProps {
+    children: (props: FieldsRenderProps) => React.ReactNode;
+}
+/**
+ * Fields component that provides form data to its children.
+ * This component accesses the form data from the service and passes it to children via render props.
+ *
+ * @component
+ * @param {FieldsProps} props - Component props
+ * @param {FieldsProps['children']} props.children - Render prop function that receives form data
+ * @example
+ * ```tsx
+ * import { Form } from '@wix/headless-forms/react';
+ *
+ * function FormFields() {
+ *   return (
+ *     <Form.Fields>
+ *       {({ form }) => (
+ *         form ? (
+ *           <div>
+ *             <h2>{form.name}</h2>
+ *             <p>{form.description}</p>
+ *           </div>
+ *         ) : null
+ *       )}
+ *     </Form.Fields>
+ *   );
+ * }
+ * ```
+ */
+export declare function Fields(props: FieldsProps): import("react").ReactNode;
+export {};

package/dist/react/core/Form.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useService, WixServices } from '@wix/services-manager-react';
-import { FormServiceDefinition, FormService, } from '../../services/form-service.js';
 import { createServicesMap } from '@wix/services-manager';
+import { FormServiceDefinition, FormService, } from '../../services/form-service.js';
 const DEFAULT_SUCCESS_MESSAGE = 'Your form has been submitted successfully.';
 /**
  * Root component that provides the Form service context to its children.
@@ -9,8 +9,9 @@ const DEFAULT_SUCCESS_MESSAGE = 'Your form has been submitted successfully.';
  *
  * @order 1
  * @component
- * @param {React.ReactNode} children - Child components that will have access to form context
- * @param {FormServiceConfig} formServiceConfig - Configuration object containing form data
+ * @param {RootProps} props - Component props
+ * @param {React.ReactNode} props.children - Child components that will have access to form context
+ * @param {FormServiceConfig} props.formServiceConfig - Configuration object containing form data
  * @example
  * ```tsx
  * import { Form } from '@wix/headless-forms/react';
@@ -47,8 +48,8 @@ const DEFAULT_SUCCESS_MESSAGE = 'Your form has been submitted successfully.';
  * }
  * ```
  */
-export function Root(props) {
-    return (_jsx(WixServices, { servicesMap: createServicesMap().addService(FormServiceDefinition, FormService, props.formServiceConfig), children: props.children }));
+export function Root({ formServiceConfig, children, }) {
+    return (_jsx(WixServices, { servicesMap: createServicesMap().addService(FormServiceDefinition, FormService, formServiceConfig), children: children }));
 }
 /**
  * Headless component for form loading state access
@@ -74,8 +75,8 @@ export function Root(props) {
  * ```
  */
 export function Loading(props) {
-    const service = useService(FormServiceDefinition);
-    const isLoading = service.isLoading?.get() || false;
+    const { isLoadingSignal } = useService(FormServiceDefinition);
+    const isLoading = isLoadingSignal.get();
     return props.children({
         isLoading,
     });
@@ -106,8 +107,8 @@ export function Loading(props) {
  * ```
  */
 export function LoadingError(props) {
-    const service = useService(FormServiceDefinition);
-    const error = service.error?.get() || null;
+    const { errorSignal } = useService(FormServiceDefinition);
+    const error = errorSignal.get();
     const hasError = !!error;
     return props.children({
         error,
@@ -140,10 +141,9 @@ export function LoadingError(props) {
  * ```
  */
 export function Error(props) {
-    const service = useService(FormServiceDefinition);
-    const submitResponse = service.submitResponse?.get() || { type: 'idle' };
-    const error = submitResponse.type === 'error' ? submitResponse.message : null;
-    const hasError = submitResponse.type === 'error';
+    // TODO: Implement submit response handling when submitResponseSignal is added to service
+    const error = null;
+    const hasError = false;
     return props.children({
         error,
         hasError,
@@ -176,14 +176,45 @@ export function Error(props) {
  * ```
  */
 export function Submitted(props) {
-    const service = useService(FormServiceDefinition);
-    const submitResponse = service.submitResponse?.get() || { type: 'idle' };
-    const isSubmitted = submitResponse.type === 'success';
-    const message = submitResponse.type === 'success'
-        ? submitResponse.message || DEFAULT_SUCCESS_MESSAGE
-        : DEFAULT_SUCCESS_MESSAGE;
+    // TODO: Implement submit response handling when submitResponseSignal is added to service
+    const isSubmitted = false;
+    const message = DEFAULT_SUCCESS_MESSAGE;
     return props.children({
         isSubmitted,
         message,
     });
 }
+/**
+ * Fields component that provides form data to its children.
+ * This component accesses the form data from the service and passes it to children via render props.
+ *
+ * @component
+ * @param {FieldsProps} props - Component props
+ * @param {FieldsProps['children']} props.children - Render prop function that receives form data
+ * @example
+ * ```tsx
+ * import { Form } from '@wix/headless-forms/react';
+ *
+ * function FormFields() {
+ *   return (
+ *     <Form.Fields>
+ *       {({ form }) => (
+ *         form ? (
+ *           <div>
+ *             <h2>{form.name}</h2>
+ *             <p>{form.description}</p>
+ *           </div>
+ *         ) : null
+ *       )}
+ *     </Form.Fields>
+ *   );
+ * }
+ * ```
+ */
+export function Fields(props) {
+    const { formSignal } = useService(FormServiceDefinition);
+    const form = formSignal.get();
+    return props.children({
+        form,
+    });
+}

package/dist/services/form-service.d.ts

@@ -1,5 +1,9 @@
 import { forms } from '@wix/forms';
-import { type Signal } from '@wix/services-definitions/core-services/signals';
+import { type ReadOnlySignal } from '@wix/services-definitions/core-services/signals';
+/**
+ * Response type for form submission operations.
+ * Represents the different states a form submission can be in.
+ */
 export type SubmitResponse = {
     type: 'success';
     message?: string;
@@ -9,181 +13,78 @@ export type SubmitResponse = {
 } | {
     type: 'idle';
 };
+/**
+ * API interface for the Form service, providing reactive form data management.
+ * This service handles loading and managing form data, loading state, and errors.
+ * It supports both pre-loaded form data and lazy loading with form IDs.
+ *
+ * @interface FormServiceAPI
+ */
 export interface FormServiceAPI {
-    form: Signal<forms.Form | null>;
-    isLoading: Signal<boolean>;
-    error: Signal<string | null>;
-    submitResponse: Signal<SubmitResponse>;
+    /** Reactive signal containing the current form data */
+    formSignal: ReadOnlySignal<forms.Form | null>;
+    /** Reactive signal indicating if a form is currently being loaded */
+    isLoadingSignal: ReadOnlySignal<boolean>;
+    /** Reactive signal containing any error message, or null if no error */
+    errorSignal: ReadOnlySignal<string | null>;
 }
+/**
+ * Service definition for the Form service.
+ * This defines the contract that the FormService must implement.
+ *
+ * @constant
+ */
 export declare const FormServiceDefinition: string & {
     __api: FormServiceAPI;
     __config: {};
     isServiceDefinition?: boolean;
 } & FormServiceAPI;
 /**
- * Configuration object for initializing the Form service.
- *
- * The Form service supports two distinct patterns for providing form data:
- *
- * **Pattern 1: Pre-loaded Form Data (SSR/SSG)**
- * - Use when you have form data available at service initialization
- * - Recommended for server-side rendering and static site generation
- * - Provides immediate form availability with no loading states
- * - Better performance and SEO as form data is available immediately
+ * Configuration type for the Form service.
+ * Supports two distinct patterns for providing form data:
+ * - Pre-loaded form data (SSR/SSG scenarios)
+ * - Lazy loading with form ID (client-side routing)
  *
- * **Pattern 2: Lazy Loading with Form ID (Client-side)**
- * - Use when you only have a form ID and need to load form data asynchronously
- * - Ideal for client-side routing and dynamic form loading
- * - Service will automatically fetch form data using the provided formId
- * - Provides loading states and error handling during form fetch
- *
- * @interface FormServiceConfig
- * @property {forms.Form} [form] - Pre-loaded form data. When provided, the service uses this data immediately without any network requests. Recommended for SSR/SSG scenarios.
- * @property {string} [formId] - Form ID for lazy loading. When provided (and no form data), the service will fetch form data asynchronously from the Wix Forms API. Ideal for client-side routing.
- *
- * @example
- * ```tsx
- * // Pattern 1: Pre-loaded form data (SSR/SSG)
- * // Server-side: Load form data first
- * const formServiceConfigResult = await loadFormServiceConfig('form-123');
- * if (formServiceConfigResult.type === 'success') {
- *   // Use pre-loaded form data
- *   <Form.Root formServiceConfig={formServiceConfigResult.config} />
- * }
- *
- * // Or with direct form data
- * const config1: FormServiceConfig = { form: myForm };
- * <Form.Root formServiceConfig={config1} />
- * ```
- *
- * @example
- * ```tsx
- * // Pattern 2: Lazy loading with form ID (Client-side)
- * // Simple formId-based loading - service handles the rest
- * const config2: FormServiceConfig = { formId: 'form-123' };
- * <Form.Root formServiceConfig={config2} />
- *
- * // With loading and error handling
- * <Form.Root formServiceConfig={{ formId: 'form-123' }}>
- *   <Form.Loading>
- *     {({ isLoading }) => isLoading ? <div>Loading form...</div> : null}
- *   </Form.Loading>
- *   <Form.LoadingError>
- *     {({ error, hasError }) => hasError ? <div>Error: {error}</div> : null}
- *   </Form.LoadingError>
- *   <Form.Fields fieldMap={FIELD_MAP} />
- * </Form.Root>
- * ```
- *
- * @example
- * ```tsx
- * // Pattern 3: Both provided (form takes precedence)
- * // The pre-loaded form data will be used, formId is ignored
- * const config3: FormServiceConfig = {
- *   form: myForm,
- *   formId: 'form-123' // This will be ignored
- * };
- * <Form.Root formServiceConfig={config3} />
- * ```
- *
- * @throws {Error} Throws an error if neither form nor formId is provided
+ * @type {FormServiceConfig}
  */
-export interface FormServiceConfig {
-    form?: forms.Form;
-    formId?: string;
-}
+export type FormServiceConfig = {
+    formId: string;
+} | {
+    form: forms.Form;
+};
 /**
- * Form service implementation that supports both pre-loaded form data and lazy loading.
- *
- * This service provides reactive state management for form data, loading states, errors, and submission responses.
- * It automatically handles form loading when only a formId is provided, making it suitable for both SSR and client-side scenarios.
- *
- * ## Service Behavior
- *
- * **Configuration Resolution:**
- * - If `form` is provided: Uses pre-loaded form data immediately (SSR/SSG pattern)
- * - If only `formId` is provided: Loads form data asynchronously from Wix Forms API
- * - If both are provided: Uses pre-loaded `form` data and ignores `formId`
- * - If neither is provided: Throws an error during service initialization
- *
- * **Loading States:**
- * - `isLoading`: `true` when loading form data via `formId`, `false` otherwise
- * - `form`: `null` initially when using `formId`, populated after successful load
- * - `error`: `null` initially, populated if form loading fails
- * - `submitResponse`: `{ type: 'idle' }` initially, updated during form submission
- *
- * **Error Handling:**
- * - Network errors during form loading are caught and stored in the `error` signal
- * - "Form not found" errors are handled when the formId doesn't exist
- * - All errors are logged to console for debugging
+ * Implementation of the Form service that manages reactive form data.
+ * This service provides signals for form data, loading state, and error handling.
+ * It supports both pre-loaded form data and lazy loading with form IDs.
  *
  * @example
  * ```tsx
- * // Service automatically handles loading states
- * const service = useService(FormServiceDefinition);
+ * // Pre-loaded form data (SSR/SSG)
+ * const formService = FormService.withConfig({ form: formData });
  *
- * // Check loading state
- * const isLoading = service.isLoading.get();
- *
- * // Access form data (null during loading)
- * const form = service.form.get();
- *
- * // Check for errors
- * const error = service.error.get();
+ * // Lazy loading with form ID (client-side)
+ * const formService = FormService.withConfig({ formId: 'form-123' });
  * ```
- *
  */
 export declare const FormService: import("@wix/services-definitions").ServiceFactory<string & {
     __api: FormServiceAPI;
     __config: {};
     isServiceDefinition?: boolean;
 } & FormServiceAPI, FormServiceConfig>;
-export type FormServiceConfigResult = {
-    type: 'success';
-    config: FormServiceConfig;
-} | {
-    type: 'notFound';
-};
 /**
- * Loads form service configuration by form ID.
- *
- * This function fetches form data from the Wix Forms API and returns a configuration
- * object that can be used to initialize the Form service. This is the recommended approach
- * for server-side rendering (SSR) and static site generation (SSG) scenarios.
- *
- * @param {string} id - The unique identifier of the form to load
- * @returns {Promise<FormServiceConfigResult>} A promise that resolves to either:
- *   - `{ type: 'success', config: FormServiceConfig }` if the form is found and loaded successfully
- *   - `{ type: 'notFound' }` if the form doesn't exist or an error occurs during loading
- *
- * @example
- * ```tsx
- * import { loadFormServiceConfig } from '@wix/headless-forms/services';
- *
- * // Server-side loading (Astro/SSR) - pre-loads form data
- * const formServiceConfigResult = await loadFormServiceConfig('form-id');
+ * Loads form service configuration from the Wix Forms API for SSR initialization.
+ * This function is designed to be used during Server-Side Rendering (SSR) to preload
+ * a specific form by ID that will be used to configure the FormService.
  *
- * if (formServiceConfigResult.type === 'notFound') {
- *   return Astro.redirect('/404');
- * }
- *
- * // Use pre-loaded form data
- * const formServiceConfig = formServiceConfigResult.config;
- * <Form.Root formServiceConfig={formServiceConfig} />
- * ```
+ * @param {string} formId - The unique identifier of the form to load
+ * @returns {Promise<FormServiceConfig>} Configuration object with pre-loaded form data
+ * @throws {Error} When the form cannot be loaded
  *
  * @example
  * ```tsx
- * // Alternative: Client-side loading with formId
- * // No need to pre-load, service handles loading automatically
- * <Form.Root formServiceConfig={{ formId: 'form-id' }}>
- *   <Form.Loading>
- *     {({ isLoading }) => isLoading ? <div>Loading...</div> : null}
- *   </Form.Loading>
- *   <Form.Fields fieldMap={FIELD_MAP} />
- * </Form.Root>
+ * // In your SSR/SSG setup
+ * const formConfig = await loadFormServiceConfig('form-123');
+ * const formService = FormService.withConfig(formConfig);
  * ```
- *
- * @throws {Error} Logs errors to console but returns 'notFound' result instead of throwing
  */
-export declare function loadFormServiceConfig(id: string): Promise<FormServiceConfigResult>;
+export declare function loadFormServiceConfig(formId: string): Promise<FormServiceConfig>;