@evanschleret/formforgeclient 1.0.0

package/dist/runtime/composables/useFormForgeManagement.d.ts

@@ -0,0 +1,40 @@
+import type { FormForgeManagementRequestOptions } from '../api/management.js';
+import type { FormForgeClient, FormForgeClientConfig, FormForgeDiffResponse, FormForgeManagementCreateInput, FormForgeManagementForm, FormForgeManagementPatchInput, FormForgeScope, FormForgeRevisionSummary } from '../types/index.js';
+export interface UseFormForgeManagementOptions {
+    endpoint?: string;
+    scope?: FormForgeScope;
+    client?: FormForgeClient;
+    clientConfig?: FormForgeClientConfig;
+}
+export interface UseFormForgeManagementMutationInputOptions {
+    idempotencyKey?: string;
+    endpoint?: string;
+    scope?: FormForgeScope;
+}
+type UseFormForgeManagementMutationOptions = string | UseFormForgeManagementMutationInputOptions | undefined;
+export declare function useFormForgeManagement(options?: UseFormForgeManagementOptions): {
+    client: FormForgeClient;
+    loading: any;
+    error: any;
+    clientError: any;
+    fieldErrors: any;
+    businessErrorCode: any;
+    hasCategoryValidationError: any;
+    forms: any;
+    lastListIncludeDeleted: any;
+    lastListEndpoint: any;
+    lastListScope: any;
+    lastListFilters: any;
+    listForms: (includeDeleted?: boolean, options?: FormForgeManagementRequestOptions) => Promise<FormForgeManagementForm[]>;
+    refreshForms: () => Promise<FormForgeManagementForm[]>;
+    refresh: () => Promise<FormForgeManagementForm[]>;
+    createForm: (input: FormForgeManagementCreateInput, options?: UseFormForgeManagementMutationOptions) => Promise<FormForgeManagementForm>;
+    patchForm: (key: string, input: FormForgeManagementPatchInput, options?: UseFormForgeManagementMutationOptions) => Promise<FormForgeManagementForm>;
+    publishForm: (key: string, options?: UseFormForgeManagementMutationOptions) => Promise<FormForgeManagementForm>;
+    unpublishForm: (key: string, options?: UseFormForgeManagementMutationOptions) => Promise<FormForgeManagementForm>;
+    deleteForm: (key: string, options?: UseFormForgeManagementMutationOptions) => Promise<FormForgeManagementForm>;
+    getRevisions: (key: string, includeDeleted?: boolean, options?: FormForgeManagementRequestOptions) => Promise<FormForgeRevisionSummary[]>;
+    getDiff: (key: string, fromVersion: number, toVersion: number, options?: FormForgeManagementRequestOptions) => Promise<FormForgeDiffResponse>;
+};
+export {};
+//# sourceMappingURL=useFormForgeManagement.d.ts.map

package/dist/runtime/composables/useFormForgeManagement.js

@@ -0,0 +1,153 @@
+import { computed, ref } from "#imports";
+import { useFormForgeClient } from "./useFormForgeClient.js";
+function isFormForgeClientError(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.status === "number" && typeof candidate.code === "string" && typeof candidate.message === "string";
+}
+export function useFormForgeManagement(options = {}) {
+  const client = options.client ?? useFormForgeClient(options.clientConfig);
+  const loading = ref(false);
+  const error = ref(null);
+  const clientError = ref(null);
+  const forms = ref([]);
+  const lastListIncludeDeleted = ref(false);
+  const lastListEndpoint = ref(options.endpoint);
+  const lastListScope = ref(options.scope);
+  const lastListFilters = ref({});
+  const fieldErrors = computed(() => clientError.value?.fieldErrors ?? {});
+  const businessErrorCode = computed(() => clientError.value?.businessCode);
+  const hasCategoryValidationError = computed(() => {
+    const errors = fieldErrors.value;
+    return errors.category !== void 0 || errors.category_key !== void 0;
+  });
+  async function withLoading(callback) {
+    loading.value = true;
+    error.value = null;
+    clientError.value = null;
+    try {
+      return await callback();
+    } catch (caughtError) {
+      error.value = caughtError instanceof Error ? caughtError.message : "Management request failed";
+      if (isFormForgeClientError(caughtError)) {
+        clientError.value = caughtError;
+      }
+      throw caughtError;
+    } finally {
+      loading.value = false;
+    }
+  }
+  function normalizeMutationOptions(options2) {
+    if (typeof options2 === "string") {
+      return {
+        idempotencyKey: options2,
+        endpoint: void 0,
+        scope: void 0
+      };
+    }
+    return {
+      idempotencyKey: options2?.idempotencyKey,
+      endpoint: options2?.endpoint ?? void 0,
+      scope: options2?.scope ?? void 0
+    };
+  }
+  function resolveRequestEndpoint(endpoint) {
+    return endpoint ?? options.endpoint;
+  }
+  function resolveRequestScope(scope) {
+    return scope ?? options.scope;
+  }
+  async function createForm(input, options2) {
+    const mutationOptions = normalizeMutationOptions(options2);
+    mutationOptions.endpoint = resolveRequestEndpoint(mutationOptions.endpoint);
+    mutationOptions.scope = resolveRequestScope(mutationOptions.scope);
+    return withLoading(() => client.createForm(input, mutationOptions));
+  }
+  async function listForms(includeDeleted = false, options2 = {}) {
+    return withLoading(async () => {
+      const endpoint = resolveRequestEndpoint(options2.endpoint);
+      const scope = resolveRequestScope(options2.scope);
+      const filters = options2.filters ?? {};
+      const response = await client.listForms(includeDeleted, {
+        endpoint,
+        scope,
+        filters
+      });
+      forms.value = response;
+      lastListIncludeDeleted.value = includeDeleted;
+      lastListEndpoint.value = endpoint;
+      lastListScope.value = scope;
+      lastListFilters.value = filters;
+      return response;
+    });
+  }
+  async function refreshForms() {
+    return listForms(lastListIncludeDeleted.value, {
+      endpoint: lastListEndpoint.value,
+      scope: lastListScope.value,
+      filters: lastListFilters.value
+    });
+  }
+  async function patchForm(key, input, options2) {
+    const mutationOptions = normalizeMutationOptions(options2);
+    mutationOptions.endpoint = resolveRequestEndpoint(mutationOptions.endpoint);
+    mutationOptions.scope = resolveRequestScope(mutationOptions.scope);
+    return withLoading(() => client.patchForm(key, input, mutationOptions));
+  }
+  async function publishForm(key, options2) {
+    const mutationOptions = normalizeMutationOptions(options2);
+    mutationOptions.endpoint = resolveRequestEndpoint(mutationOptions.endpoint);
+    mutationOptions.scope = resolveRequestScope(mutationOptions.scope);
+    return withLoading(() => client.publishForm(key, mutationOptions));
+  }
+  async function unpublishForm(key, options2) {
+    const mutationOptions = normalizeMutationOptions(options2);
+    mutationOptions.endpoint = resolveRequestEndpoint(mutationOptions.endpoint);
+    mutationOptions.scope = resolveRequestScope(mutationOptions.scope);
+    return withLoading(() => client.unpublishForm(key, mutationOptions));
+  }
+  async function deleteForm(key, options2) {
+    const mutationOptions = normalizeMutationOptions(options2);
+    mutationOptions.endpoint = resolveRequestEndpoint(mutationOptions.endpoint);
+    mutationOptions.scope = resolveRequestScope(mutationOptions.scope);
+    return withLoading(() => client.deleteForm(key, mutationOptions));
+  }
+  async function getRevisions(key, includeDeleted = false, options2 = {}) {
+    return withLoading(() => client.getRevisions(key, includeDeleted, {
+      endpoint: resolveRequestEndpoint(options2.endpoint),
+      scope: resolveRequestScope(options2.scope)
+    }));
+  }
+  async function getDiff(key, fromVersion, toVersion, options2 = {}) {
+    return withLoading(() => client.getDiff(key, fromVersion, toVersion, {
+      endpoint: resolveRequestEndpoint(options2.endpoint),
+      scope: resolveRequestScope(options2.scope)
+    }));
+  }
+  return {
+    client,
+    loading,
+    error,
+    clientError,
+    fieldErrors,
+    businessErrorCode,
+    hasCategoryValidationError,
+    forms,
+    lastListIncludeDeleted,
+    lastListEndpoint,
+    lastListScope,
+    lastListFilters,
+    listForms,
+    refreshForms,
+    refresh: refreshForms,
+    createForm,
+    patchForm,
+    publishForm,
+    unpublishForm,
+    deleteForm,
+    getRevisions,
+    getDiff
+  };
+}

package/dist/runtime/composables/useFormForgeResolver.d.ts

@@ -0,0 +1,28 @@
+import type { FormForgeClient, FormForgeClientConfig, FormForgeFormSchema, FormForgeScope, FormForgeSubmissionPayload } from '../types/index.js';
+import type { FormForgeRequestOptions } from '../api/request.js';
+export interface UseFormForgeResolverOptions {
+    key: string;
+    version?: string;
+    endpoint?: string;
+    scope?: FormForgeScope;
+    delay?: number;
+    payload?: () => FormForgeSubmissionPayload;
+    immediate?: boolean;
+    watchPayload?: boolean;
+    debug?: boolean;
+    client?: FormForgeClient;
+    clientConfig?: FormForgeClientConfig;
+}
+export interface FormForgeResolveOptions extends FormForgeRequestOptions {
+    debug?: boolean;
+}
+export declare function useFormForgeResolver(options: UseFormForgeResolverOptions): {
+    client: FormForgeClient;
+    schema: any;
+    resolving: any;
+    error: any;
+    resolve: (payload?: FormForgeSubmissionPayload, resolveOptions?: FormForgeResolveOptions) => Promise<FormForgeFormSchema>;
+    resolveNow: (payload?: FormForgeSubmissionPayload, resolveOptions?: FormForgeResolveOptions) => Promise<FormForgeFormSchema>;
+    clearScheduledResolve: () => void;
+};
+//# sourceMappingURL=useFormForgeResolver.d.ts.map

package/dist/runtime/composables/useFormForgeResolver.js

@@ -0,0 +1,88 @@
+import { onBeforeUnmount, ref, watch } from "#imports";
+import { toFormForgeJsonSubmissionPayload } from "../utils/submission.js";
+import { useFormForgeClient } from "./useFormForgeClient.js";
+export function useFormForgeResolver(options) {
+  const client = options.client ?? useFormForgeClient(options.clientConfig);
+  const delay = options.delay ?? 200;
+  const resolving = ref(false);
+  const error = ref(null);
+  const schema = ref(null);
+  let timer;
+  let requestId = 0;
+  function clearScheduledResolve() {
+    if (timer === void 0) {
+      return;
+    }
+    clearTimeout(timer);
+    timer = void 0;
+  }
+  async function resolveNow(payload = {}, resolveOptions = {}) {
+    const nextRequestId = requestId + 1;
+    requestId = nextRequestId;
+    resolving.value = true;
+    error.value = null;
+    try {
+      const resolved = await client.resolveForm(
+        options.key,
+        {
+          payload: toFormForgeJsonSubmissionPayload(payload),
+          debug: resolveOptions.debug === true
+        },
+        {
+          version: options.version,
+          endpoint: resolveOptions.endpoint ?? options.endpoint,
+          scope: resolveOptions.scope ?? options.scope
+        }
+      );
+      if (requestId === nextRequestId) {
+        schema.value = resolved;
+      }
+      return resolved;
+    } catch (caughtError) {
+      if (requestId === nextRequestId) {
+        error.value = caughtError instanceof Error ? caughtError.message : "Failed to resolve schema";
+      }
+      throw caughtError;
+    } finally {
+      if (requestId === nextRequestId) {
+        resolving.value = false;
+      }
+    }
+  }
+  function resolve(payload = {}, resolveOptions = {}) {
+    clearScheduledResolve();
+    return new Promise((resolvePromise, rejectPromise) => {
+      timer = setTimeout(() => {
+        resolveNow(payload, resolveOptions).then(resolvePromise).catch(rejectPromise);
+      }, delay);
+    });
+  }
+  onBeforeUnmount(() => {
+    clearScheduledResolve();
+  });
+  if (options.payload !== void 0 && options.watchPayload === true) {
+    watch(options.payload, (nextPayload) => {
+      resolve(nextPayload, {
+        debug: options.debug
+      }).catch(() => {
+      });
+    }, {
+      deep: true
+    });
+  }
+  if (options.payload !== void 0 && options.immediate === true) {
+    resolve(options.payload(), {
+      debug: options.debug
+    }).catch(() => {
+    });
+  }
+  return {
+    client,
+    schema,
+    resolving,
+    error,
+    resolve,
+    resolveNow,
+    clearScheduledResolve
+  };
+}

package/dist/runtime/composables/useFormForgeResponses.d.ts

@@ -0,0 +1,45 @@
+import type { FormForgeRequestOptions } from '../api/request.js';
+import type { FormForgeClient, FormForgeClientConfig, FormForgeJsonObject, FormForgeResponsesListResponse, FormForgeScope } from '../types/index.js';
+type FormForgeResponsesQueryValue = string | number | boolean | undefined;
+type FormForgeResponsesQuery = Record<string, FormForgeResponsesQueryValue>;
+export interface UseFormForgeResponsesQuerySync {
+    enabled?: boolean;
+    pageKey?: string;
+    perPageKey?: string;
+    extraKeys?: string[];
+}
+export interface UseFormForgeResponsesOptions {
+    key: string;
+    immediate?: boolean;
+    endpoint?: string;
+    scope?: FormForgeScope;
+    client?: FormForgeClient;
+    clientConfig?: FormForgeClientConfig;
+    querySync?: UseFormForgeResponsesQuerySync;
+}
+export type FormForgeResponsesRequestOptions = FormForgeRequestOptions;
+export interface FormForgeResponsesRefreshOptions {
+    mode?: 'auto' | 'list' | 'resource';
+    query?: FormForgeResponsesQuery;
+    submissionId?: string;
+    endpoint?: string;
+    scope?: FormForgeScope;
+}
+export declare function useFormForgeResponses(options: UseFormForgeResponsesOptions): {
+    client: FormForgeClient;
+    loading: any;
+    error: any;
+    list: any;
+    lastMeta: any;
+    current: any;
+    lastListQuery: any;
+    lastListEndpoint: any;
+    lastListScope: any;
+    lastSubmissionId: any;
+    refresh: (options?: FormForgeResponsesRefreshOptions) => Promise<FormForgeResponsesListResponse | FormForgeJsonObject>;
+    listResponses: (query?: FormForgeResponsesQuery, requestOptions?: FormForgeResponsesRequestOptions) => Promise<FormForgeResponsesListResponse>;
+    getResponse: (submissionId: string, requestOptions?: FormForgeResponsesRequestOptions) => Promise<FormForgeJsonObject>;
+    deleteResponse: (submissionId: string, requestOptions?: FormForgeResponsesRequestOptions) => Promise<FormForgeJsonObject>;
+};
+export {};
+//# sourceMappingURL=useFormForgeResponses.d.ts.map

package/dist/runtime/composables/useFormForgeResponses.js

@@ -0,0 +1,206 @@
+import { ref, useRoute, watch } from "#imports";
+import { useFormForgeClient } from "./useFormForgeClient.js";
+function normalizeRouteQueryValue(value) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return void 0;
+    }
+    return normalizeRouteQueryValue(value[0]);
+  }
+  if (value === null || value === void 0 || value === "") {
+    return void 0;
+  }
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  if (/^-?\d+$/.test(value)) {
+    return Number(value);
+  }
+  return value;
+}
+export function useFormForgeResponses(options) {
+  const client = options.client ?? useFormForgeClient(options.clientConfig);
+  const route = useRoute();
+  const loading = ref(false);
+  const error = ref(null);
+  const list = ref([]);
+  const lastMeta = ref(void 0);
+  const current = ref(null);
+  const lastListQuery = ref({});
+  const lastListEndpoint = ref(options.endpoint);
+  const lastListScope = ref(options.scope);
+  const lastSubmissionId = ref(null);
+  const lastMode = ref(null);
+  const immediateLoad = options.immediate ?? true;
+  const syncOptions = {
+    enabled: options.querySync?.enabled ?? true,
+    pageKey: options.querySync?.pageKey ?? "page",
+    perPageKey: options.querySync?.perPageKey ?? "per_page",
+    extraKeys: options.querySync?.extraKeys ?? []
+  };
+  function resolveRouteListQuery() {
+    if (syncOptions.enabled === false) {
+      return {};
+    }
+    const query = {};
+    const keys = [syncOptions.pageKey, syncOptions.perPageKey, ...syncOptions.extraKeys];
+    for (const key of keys) {
+      const rawValue = route.query[key];
+      const value = normalizeRouteQueryValue(rawValue);
+      if (value !== void 0) {
+        query[key] = value;
+      }
+    }
+    return query;
+  }
+  function createListQuery(override = {}) {
+    return {
+      ...resolveRouteListQuery(),
+      ...override
+    };
+  }
+  function resolveEndpoint(requestOptions = {}) {
+    return requestOptions.endpoint ?? options.endpoint;
+  }
+  function resolveScope(requestOptions = {}) {
+    return requestOptions.scope ?? options.scope;
+  }
+  async function withLoading(callback) {
+    loading.value = true;
+    error.value = null;
+    try {
+      return await callback();
+    } catch (caughtError) {
+      error.value = caughtError instanceof Error ? caughtError.message : "Responses request failed";
+      throw caughtError;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function listResponses(query = {}, requestOptions = {}) {
+    return withLoading(async () => {
+      const resolvedQuery = createListQuery(query);
+      const endpoint = resolveEndpoint(requestOptions);
+      const scope = resolveScope(requestOptions);
+      const response = await client.listResponses(options.key, resolvedQuery, {
+        endpoint,
+        scope
+      });
+      list.value = response.data;
+      lastMeta.value = response.meta;
+      lastListQuery.value = resolvedQuery;
+      lastListEndpoint.value = endpoint;
+      lastListScope.value = scope;
+      lastMode.value = "list";
+      return response;
+    });
+  }
+  async function getResponse(submissionId, requestOptions = {}) {
+    return withLoading(async () => {
+      const response = await client.getResponse(options.key, submissionId, {
+        endpoint: resolveEndpoint(requestOptions),
+        scope: resolveScope(requestOptions)
+      });
+      current.value = response;
+      lastSubmissionId.value = submissionId;
+      lastMode.value = "resource";
+      return response;
+    });
+  }
+  async function deleteResponse(submissionId, requestOptions = {}) {
+    return withLoading(async () => {
+      const response = await client.deleteResponse(options.key, submissionId, {
+        endpoint: resolveEndpoint(requestOptions),
+        scope: resolveScope(requestOptions)
+      });
+      current.value = response;
+      list.value = list.value.filter((item) => {
+        const id = item.submission_id;
+        return !(typeof id === "string" && id === submissionId);
+      });
+      return response;
+    });
+  }
+  async function refresh(options2 = {}) {
+    const mode = options2.mode ?? "auto";
+    const endpoint = options2.endpoint ?? lastListEndpoint.value ?? void 0;
+    const scope = options2.scope ?? lastListScope.value;
+    if (mode === "list") {
+      return listResponses(options2.query ?? lastListQuery.value, {
+        endpoint,
+        scope
+      });
+    }
+    if (mode === "resource") {
+      const submissionId = options2.submissionId ?? lastSubmissionId.value;
+      if (typeof submissionId === "string" && submissionId !== "") {
+        return getResponse(submissionId, {
+          endpoint,
+          scope
+        });
+      }
+      return listResponses(options2.query ?? lastListQuery.value, {
+        endpoint,
+        scope
+      });
+    }
+    if (lastMode.value === "resource") {
+      const submissionId = options2.submissionId ?? lastSubmissionId.value;
+      if (typeof submissionId === "string" && submissionId !== "") {
+        return getResponse(submissionId, {
+          endpoint,
+          scope
+        });
+      }
+    }
+    return listResponses(options2.query ?? lastListQuery.value, {
+      endpoint,
+      scope
+    });
+  }
+  if (syncOptions.enabled === true) {
+    watch(
+      () => [
+        route.query[syncOptions.pageKey],
+        route.query[syncOptions.perPageKey],
+        ...syncOptions.extraKeys.map((key) => route.query[key])
+      ],
+      () => {
+        listResponses({}, {
+          endpoint: lastListEndpoint.value ?? options.endpoint,
+          scope: lastListScope.value ?? options.scope
+        }).catch(() => {
+        });
+      },
+      {
+        immediate: false
+      }
+    );
+  }
+  if (immediateLoad === true) {
+    listResponses({}, {
+      endpoint: options.endpoint,
+      scope: options.scope
+    }).catch(() => {
+    });
+  }
+  return {
+    client,
+    loading,
+    error,
+    list,
+    lastMeta,
+    current,
+    lastListQuery,
+    lastListEndpoint,
+    lastListScope,
+    lastSubmissionId,
+    refresh,
+    listResponses,
+    getResponse,
+    deleteResponse
+  };
+}

package/dist/runtime/composables/useFormForgeSchema.d.ts

@@ -0,0 +1,24 @@
+import type { FormForgeClient, FormForgeClientConfig, FormForgeFormSchema, FormForgeSchemaVersionsResponse, FormForgeScope } from '../types/index.js';
+import type { FormForgeRequestOptions } from '../api/request.js';
+export interface UseFormForgeSchemaOptions {
+    key: string;
+    version?: string;
+    endpoint?: string;
+    scope?: FormForgeScope;
+    immediate?: boolean;
+    loadVersions?: boolean;
+    client?: FormForgeClient;
+    clientConfig?: FormForgeClientConfig;
+}
+export type FormForgeSchemaFetchOptions = FormForgeRequestOptions;
+export declare function useFormForgeSchema(options: UseFormForgeSchemaOptions): {
+    client: FormForgeClient;
+    schema: any;
+    versions: any;
+    loading: any;
+    error: any;
+    fetchSchema: (requestOptions?: FormForgeSchemaFetchOptions) => Promise<FormForgeFormSchema>;
+    fetchVersions: (requestOptions?: FormForgeSchemaFetchOptions) => Promise<FormForgeSchemaVersionsResponse>;
+    refresh: (requestOptions?: FormForgeSchemaFetchOptions) => Promise<FormForgeFormSchema>;
+};
+//# sourceMappingURL=useFormForgeSchema.d.ts.map

package/dist/runtime/composables/useFormForgeSchema.js

@@ -0,0 +1,69 @@
+import { ref } from "#imports";
+import { useFormForgeClient } from "./useFormForgeClient.js";
+export function useFormForgeSchema(options) {
+  const client = options.client ?? useFormForgeClient(options.clientConfig);
+  const schema = ref(null);
+  const versions = ref(null);
+  const loading = ref(false);
+  const error = ref(null);
+  function resolveEndpoint(requestOptions = {}) {
+    return requestOptions.endpoint ?? options.endpoint;
+  }
+  function resolveScope(requestOptions = {}) {
+    return requestOptions.scope ?? options.scope;
+  }
+  async function fetchSchema(requestOptions = {}) {
+    loading.value = true;
+    error.value = null;
+    try {
+      const endpoint = resolveEndpoint(requestOptions);
+      const scope = resolveScope(requestOptions);
+      const nextSchema = options.version !== void 0 && options.version !== "" ? await client.getFormVersion(options.key, options.version, { endpoint, scope }) : await client.getForm(options.key, { endpoint, scope });
+      schema.value = nextSchema;
+      return nextSchema;
+    } catch (caughtError) {
+      error.value = caughtError instanceof Error ? caughtError.message : "Failed to fetch schema";
+      throw caughtError;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function fetchVersions(requestOptions = {}) {
+    loading.value = true;
+    error.value = null;
+    try {
+      const nextVersions = await client.getFormVersions(options.key, {
+        endpoint: resolveEndpoint(requestOptions),
+        scope: resolveScope(requestOptions)
+      });
+      versions.value = nextVersions;
+      return nextVersions;
+    } catch (caughtError) {
+      error.value = caughtError instanceof Error ? caughtError.message : "Failed to fetch schema versions";
+      throw caughtError;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function refresh(requestOptions = {}) {
+    const nextSchema = await fetchSchema(requestOptions);
+    if (options.loadVersions === true) {
+      await fetchVersions(requestOptions);
+    }
+    return nextSchema;
+  }
+  if (options.immediate !== false) {
+    refresh().catch(() => {
+    });
+  }
+  return {
+    client,
+    schema,
+    versions,
+    loading,
+    error,
+    fetchSchema,
+    fetchVersions,
+    refresh
+  };
+}

package/dist/runtime/composables/useFormForgeSubmission.d.ts

@@ -0,0 +1,12 @@
+import type { FormForgeSubmitOptions, UseFormForgeSubmitOptions } from './useFormForgeSubmit.js';
+export type UseFormForgeSubmissionOptions = UseFormForgeSubmitOptions;
+export type FormForgeSubmissionOptions = FormForgeSubmitOptions;
+export declare function useFormForgeSubmission(options: UseFormForgeSubmissionOptions): {
+    client: import("..").FormForgeClient;
+    submitting: any;
+    fieldErrors: any;
+    error: any;
+    response: any;
+    submit: (submitOptions?: FormForgeSubmitOptions) => Promise<import("..").FormForgeSubmissionResponse>;
+};
+//# sourceMappingURL=useFormForgeSubmission.d.ts.map

package/dist/runtime/composables/useFormForgeSubmission.js

@@ -0,0 +1,4 @@
+import { useFormForgeSubmit } from "./useFormForgeSubmit.js";
+export function useFormForgeSubmission(options) {
+  return useFormForgeSubmit(options);
+}