@evanschleret/formforgeclient 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Evan Schleret
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+<p align="center">
+  <img src=".github/assets/banner.png" alt="FormForge banner" width="100%" />
+</p>
+
+<h1 align="center">FormForge Client</h1>
+
+<p align="center">
+  Nuxt 4 client and Nuxt UI v4 renderer for FormForge.
+</p>
+
+<p align="center">
+  <a href="https://github.com/EvanSchleret/FormForgeClient/actions/workflows/ci.yml"><img src="https://github.com/EvanSchleret/FormForgeClient/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
+  <a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-22c55e" alt="MIT License" /></a>
+  <img src="https://img.shields.io/badge/Nuxt-4.x-00DC82" alt="Nuxt 4.x" />
+  <img src="https://img.shields.io/badge/Nuxt_UI-4.x-0EA5E9" alt="Nuxt UI 4.x" />
+</p>
+
+## Documentation
+
+Full documentation is available at:
+
+- [formforge.schleret.ch](https://formforge.schleret.ch)
+
+Use this README as a quick start only.
+
+## Requirements
+
+- Nuxt `4.x`
+- `@nuxt/ui` `4.x`
+- Node.js `>=20` or Bun `>=1.3`
+
+## Install
+
+```bash
+bun add @evanschleret/formforgeclient
+```
+
+## Minimal setup
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['@nuxt/ui', '@evanschleret/formforgeclient'],
+  formforgeClient: {
+    baseURL: '/api/formforge/v1',
+    credentials: 'include'
+  }
+})
+```
+
+## Minimal renderer usage
+
+```vue
+<script setup lang="ts">
+const route = useRoute()
+</script>
+
+<template>
+  <FormForgeRenderer :form-key="String(route.params.form)" />
+</template>
+```
+
+## Scoped routes quick example
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  formforgeClient: {
+    baseURL: '/api/formforge/v1',
+    scopedRoutes: {
+      team: {
+        prefix: 'teams/{team}',
+        paramsFromRoute: {
+          team: 'team'
+        }
+      }
+    },
+    defaultScope: 'team'
+  }
+})
+```
+
+```ts
+const management = useFormForgeManagement()
+
+const forms = await management.listForms(false)
+```
+
+## Useful links
+
+- Backend package: [evanschleret/formforge](https://github.com/EvanSchleret/formforge)
+- Security policy: [SECURITY.md](SECURITY.md)
+- Contributing: [CONTRIBUTING.md](CONTRIBUTING.md)
+- License: [LICENSE](LICENSE)

package/dist/module.cjs

@@ -0,0 +1,112 @@
+'use strict';
+
+const kit = require('@nuxt/kit');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const module$1 = kit.defineNuxtModule({
+  meta: {
+    name: "@evanschleret/formforgeclient",
+    configKey: "formforgeClient",
+    compatibility: {
+      nuxt: ">=4.0.0"
+    }
+  },
+  defaults: {
+    baseURL: "/api/formforge/v1",
+    scopedRoutes: {},
+    defaultScope: void 0,
+    scopeParams: {},
+    credentials: "include",
+    headers: {},
+    uploadMode: "staged",
+    datetimeMode: "offset",
+    locale: "en",
+    autoImports: true
+  },
+  setup(options, nuxt) {
+    const resolver = kit.createResolver((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('module.cjs', document.baseURI).href)));
+    const runtimeConfig = nuxt.options.runtimeConfig.public.formforge;
+    nuxt.options.runtimeConfig.public.formforge = {
+      ...runtimeConfig,
+      baseURL: options.baseURL,
+      baseURLParams: options.baseURLParams,
+      scopedRoutes: options.scopedRoutes,
+      defaultScope: options.defaultScope,
+      scopeParams: options.scopeParams,
+      credentials: options.credentials,
+      headers: options.headers,
+      uploadMode: options.uploadMode,
+      datetimeMode: options.datetimeMode,
+      locale: options.locale
+    };
+    kit.addPlugin(resolver.resolve("./runtime/plugin"));
+    kit.addComponent({
+      name: "FormForgeRenderer",
+      filePath: resolver.resolve("./runtime/renderers/default/FormForgeRenderer.vue")
+    });
+    kit.addComponent({
+      name: "FormForgeBuilder",
+      filePath: resolver.resolve("./runtime/renderers/default/FormForgeBuilder.vue")
+    });
+    kit.addComponent({
+      name: "FormForgeResponse",
+      filePath: resolver.resolve("./runtime/renderers/default/FormForgeResponse.vue")
+    });
+    kit.addComponent({
+      name: "FormForgeCategoryCreateModal",
+      filePath: resolver.resolve("./runtime/renderers/default/FormForgeCategoryCreateModal.vue")
+    });
+    if (options.autoImports === true) {
+      kit.addImports([
+        { from: resolver.resolve("./runtime/composables/useFormForgeApi"), name: "useFormForgeApi" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeClient"), name: "useFormForgeClient" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeSchema"), name: "useFormForgeSchema" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeGetForm"), name: "useFormForgeGetForm" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeI18n"), name: "useFormForgeI18n" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeResolver"), name: "useFormForgeResolver" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeDrafts"), name: "useFormForgeDrafts" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeUploads"), name: "useFormForgeUploads" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeForm"), name: "useFormForgeForm" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeSubmit"), name: "useFormForgeSubmit" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeSubmission"), name: "useFormForgeSubmission" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeResponses"), name: "useFormForgeResponses" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeCategory"), name: "useFormForgeCategory" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeCategory"), name: "useFormForgeCategoryOptions" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeManagement"), name: "useFormForgeManagement" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeWizard"), name: "useFormForgeWizard" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeBuilder"), name: "useFormForgeBuilder" }
+      ]);
+    }
+    const typeTemplate = kit.addTypeTemplate({
+      filename: "types/formforge-client.d.ts",
+      getContents: () => `
+import type { FormForgeBeforeRequestContext, FormForgeClient } from '@evanschleret/formforgeclient/runtime'
+
+declare module '#app' {
+  interface NuxtApp {
+    $formforge: FormForgeClient
+  }
+
+  interface RuntimeNuxtHooks {
+    'formforge:beforeRequest': (context: FormForgeBeforeRequestContext) => void | Promise<void>
+  }
+}
+
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    $formforge: FormForgeClient
+  }
+}
+
+export {}
+`
+    });
+    nuxt.hook("prepare:types", ({ references }) => {
+      references.push({
+        path: typeTemplate.dst
+      });
+    });
+  }
+});
+
+module.exports = module$1;

package/dist/module.d.cts

@@ -0,0 +1,20 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { FormForgeScopedRouteMap, FormForgeScopeParams, FormForgeUploadMode, FormForgeDatetimeMode } from '../dist/runtime/types/index.js';
+
+interface ModuleOptions {
+    baseURL?: string;
+    baseURLParams?: Record<string, string | number | undefined>;
+    scopedRoutes?: FormForgeScopedRouteMap;
+    defaultScope?: string;
+    scopeParams?: FormForgeScopeParams;
+    credentials?: RequestCredentials;
+    headers?: Record<string, string>;
+    uploadMode?: FormForgeUploadMode;
+    datetimeMode?: FormForgeDatetimeMode;
+    locale?: string;
+    autoImports?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export = _default;
+export type { ModuleOptions };

package/dist/module.d.mts

@@ -0,0 +1,20 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { FormForgeScopedRouteMap, FormForgeScopeParams, FormForgeUploadMode, FormForgeDatetimeMode } from '../dist/runtime/types/index.js';
+
+interface ModuleOptions {
+    baseURL?: string;
+    baseURLParams?: Record<string, string | number | undefined>;
+    scopedRoutes?: FormForgeScopedRouteMap;
+    defaultScope?: string;
+    scopeParams?: FormForgeScopeParams;
+    credentials?: RequestCredentials;
+    headers?: Record<string, string>;
+    uploadMode?: FormForgeUploadMode;
+    datetimeMode?: FormForgeDatetimeMode;
+    locale?: string;
+    autoImports?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.d.ts

@@ -0,0 +1,20 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { FormForgeScopedRouteMap, FormForgeScopeParams, FormForgeUploadMode, FormForgeDatetimeMode } from '../dist/runtime/types/index.js';
+
+interface ModuleOptions {
+    baseURL?: string;
+    baseURLParams?: Record<string, string | number | undefined>;
+    scopedRoutes?: FormForgeScopedRouteMap;
+    defaultScope?: string;
+    scopeParams?: FormForgeScopeParams;
+    credentials?: RequestCredentials;
+    headers?: Record<string, string>;
+    uploadMode?: FormForgeUploadMode;
+    datetimeMode?: FormForgeDatetimeMode;
+    locale?: string;
+    autoImports?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export = _default;
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "@evanschleret/formforgeclient",
+  "configKey": "formforgeClient",
+  "compatibility": {
+    "nuxt": ">=4.0.0"
+  },
+  "version": "1.0.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,109 @@
+import { defineNuxtModule, createResolver, addPlugin, addComponent, addImports, addTypeTemplate } from '@nuxt/kit';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@evanschleret/formforgeclient",
+    configKey: "formforgeClient",
+    compatibility: {
+      nuxt: ">=4.0.0"
+    }
+  },
+  defaults: {
+    baseURL: "/api/formforge/v1",
+    scopedRoutes: {},
+    defaultScope: void 0,
+    scopeParams: {},
+    credentials: "include",
+    headers: {},
+    uploadMode: "staged",
+    datetimeMode: "offset",
+    locale: "en",
+    autoImports: true
+  },
+  setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    const runtimeConfig = nuxt.options.runtimeConfig.public.formforge;
+    nuxt.options.runtimeConfig.public.formforge = {
+      ...runtimeConfig,
+      baseURL: options.baseURL,
+      baseURLParams: options.baseURLParams,
+      scopedRoutes: options.scopedRoutes,
+      defaultScope: options.defaultScope,
+      scopeParams: options.scopeParams,
+      credentials: options.credentials,
+      headers: options.headers,
+      uploadMode: options.uploadMode,
+      datetimeMode: options.datetimeMode,
+      locale: options.locale
+    };
+    addPlugin(resolver.resolve("./runtime/plugin"));
+    addComponent({
+      name: "FormForgeRenderer",
+      filePath: resolver.resolve("./runtime/renderers/default/FormForgeRenderer.vue")
+    });
+    addComponent({
+      name: "FormForgeBuilder",
+      filePath: resolver.resolve("./runtime/renderers/default/FormForgeBuilder.vue")
+    });
+    addComponent({
+      name: "FormForgeResponse",
+      filePath: resolver.resolve("./runtime/renderers/default/FormForgeResponse.vue")
+    });
+    addComponent({
+      name: "FormForgeCategoryCreateModal",
+      filePath: resolver.resolve("./runtime/renderers/default/FormForgeCategoryCreateModal.vue")
+    });
+    if (options.autoImports === true) {
+      addImports([
+        { from: resolver.resolve("./runtime/composables/useFormForgeApi"), name: "useFormForgeApi" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeClient"), name: "useFormForgeClient" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeSchema"), name: "useFormForgeSchema" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeGetForm"), name: "useFormForgeGetForm" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeI18n"), name: "useFormForgeI18n" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeResolver"), name: "useFormForgeResolver" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeDrafts"), name: "useFormForgeDrafts" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeUploads"), name: "useFormForgeUploads" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeForm"), name: "useFormForgeForm" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeSubmit"), name: "useFormForgeSubmit" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeSubmission"), name: "useFormForgeSubmission" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeResponses"), name: "useFormForgeResponses" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeCategory"), name: "useFormForgeCategory" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeCategory"), name: "useFormForgeCategoryOptions" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeManagement"), name: "useFormForgeManagement" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeWizard"), name: "useFormForgeWizard" },
+        { from: resolver.resolve("./runtime/composables/useFormForgeBuilder"), name: "useFormForgeBuilder" }
+      ]);
+    }
+    const typeTemplate = addTypeTemplate({
+      filename: "types/formforge-client.d.ts",
+      getContents: () => `
+import type { FormForgeBeforeRequestContext, FormForgeClient } from '@evanschleret/formforgeclient/runtime'
+
+declare module '#app' {
+  interface NuxtApp {
+    $formforge: FormForgeClient
+  }
+
+  interface RuntimeNuxtHooks {
+    'formforge:beforeRequest': (context: FormForgeBeforeRequestContext) => void | Promise<void>
+  }
+}
+
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    $formforge: FormForgeClient
+  }
+}
+
+export {}
+`
+    });
+    nuxt.hook("prepare:types", ({ references }) => {
+      references.push({
+        path: typeTemplate.dst
+      });
+    });
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/api/categories.d.ts

@@ -0,0 +1,9 @@
+import type { FormForgeCategory, FormForgeCategoryCreateInput, FormForgeCategoryListQuery, FormForgeCategoryListResponse, FormForgeCategoryUpdateInput, FormForgeHttpAdapter } from '../types/index.js';
+import type { FormForgeMutationOptions } from './management.js';
+import { type FormForgeRequestOptions } from './request.js';
+export declare function fetchFormForgeCategories(http: FormForgeHttpAdapter, query?: FormForgeCategoryListQuery, options?: FormForgeRequestOptions): Promise<FormForgeCategoryListResponse>;
+export declare function fetchFormForgeCategory(http: FormForgeHttpAdapter, categoryKey: string, options?: FormForgeRequestOptions): Promise<FormForgeCategory>;
+export declare function createFormForgeCategory(http: FormForgeHttpAdapter, input: FormForgeCategoryCreateInput, options?: FormForgeMutationOptions): Promise<FormForgeCategory>;
+export declare function patchFormForgeCategory(http: FormForgeHttpAdapter, categoryKey: string, input: FormForgeCategoryUpdateInput, options?: FormForgeMutationOptions): Promise<FormForgeCategory>;
+export declare function deleteFormForgeCategory(http: FormForgeHttpAdapter, categoryKey: string, options?: FormForgeMutationOptions): Promise<FormForgeCategory>;
+//# sourceMappingURL=categories.d.ts.map

package/dist/runtime/api/categories.js

@@ -0,0 +1,83 @@
+import { normalizeFormForgeCategory, normalizeFormForgeCategoryListResponse } from "../utils/category.js";
+import { pickFormForgeDataEnvelope } from "../utils/object.js";
+import { resolveEndpointPath } from "./request.js";
+function withMutationHeaders(options = {}) {
+  if (options.idempotencyKey === void 0 || options.idempotencyKey === "") {
+    return {};
+  }
+  return {
+    "Idempotency-Key": options.idempotencyKey
+  };
+}
+function toJsonObject(input) {
+  return JSON.parse(JSON.stringify(input));
+}
+function normalizeSingleCategory(payload) {
+  const dataEnvelope = pickFormForgeDataEnvelope(payload);
+  const normalized = normalizeFormForgeCategory(dataEnvelope);
+  if (normalized !== null) {
+    return normalized;
+  }
+  return {
+    id: 0,
+    key: "",
+    name: "",
+    description: null,
+    is_active: false,
+    meta: {},
+    created_at: null,
+    updated_at: null
+  };
+}
+export async function fetchFormForgeCategories(http, query = {}, options = {}) {
+  const resolvedQuery = {
+    per_page: query.per_page,
+    search: query.search,
+    is_active: query.is_active === void 0 ? void 0 : query.is_active ? 1 : 0
+  };
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, "/categories", {}, options.scope),
+    method: "GET",
+    query: resolvedQuery
+  });
+  return normalizeFormForgeCategoryListResponse(response.data);
+}
+export async function fetchFormForgeCategory(http, categoryKey, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/categories/${categoryKey}`, {
+      categoryKey
+    }, options.scope),
+    method: "GET"
+  });
+  return normalizeSingleCategory(response.data);
+}
+export async function createFormForgeCategory(http, input, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, "/categories", {}, options.scope),
+    method: "POST",
+    headers: withMutationHeaders(options),
+    json: toJsonObject(input)
+  });
+  return normalizeSingleCategory(response.data);
+}
+export async function patchFormForgeCategory(http, categoryKey, input, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/categories/${categoryKey}`, {
+      categoryKey
+    }, options.scope),
+    method: "PATCH",
+    headers: withMutationHeaders(options),
+    json: toJsonObject(input)
+  });
+  return normalizeSingleCategory(response.data);
+}
+export async function deleteFormForgeCategory(http, categoryKey, options = {}) {
+  const response = await http({
+    path: resolveEndpointPath(options.endpoint, `/categories/${categoryKey}`, {
+      categoryKey
+    }, options.scope),
+    method: "DELETE",
+    headers: withMutationHeaders(options)
+  });
+  return normalizeSingleCategory(response.data);
+}

package/dist/runtime/api/client.d.ts

@@ -0,0 +1,45 @@
+import type { FormForgeCategory, FormForgeCategoryCreateInput, FormForgeCategoryListQuery, FormForgeCategoryListResponse, FormForgeCategoryUpdateInput, FormForgeClientConfig, FormForgeDraftResponse, FormForgeDraftSaveInput, FormForgeDiffResponse, FormForgeFormSchema, FormForgeJsonObject, FormForgeManagementCreateInput, FormForgeManagementForm, FormForgeManagementPatchInput, FormForgeResolveInput, FormForgeResponsesListResponse, FormForgeRevisionSummary, FormForgeSchemaVersionsResponse, FormForgeStageUploadInput, FormForgeStagedUploadResponse, FormForgeSubmitInput, FormForgeSubmissionResponse } from '../types/index.js';
+import { type FormForgeManagementRequestOptions, type FormForgeMutationOptions } from './management.js';
+import type { FormForgeRequestOptions } from './request.js';
+export interface FormForgeSubmitRequestOptions extends FormForgeRequestOptions {
+    version?: string;
+}
+export interface FormForgeSubmitMultipartOptions extends FormForgeRequestOptions {
+    version?: string;
+    test?: boolean;
+}
+export type FormForgeSchemaRequestOptions = FormForgeRequestOptions;
+export type FormForgeDraftRequestOptions = FormForgeRequestOptions;
+export type FormForgeResponsesRequestOptions = FormForgeRequestOptions;
+export type FormForgeCategoryRequestOptions = FormForgeRequestOptions;
+export interface FormForgeClient {
+    config: Readonly<FormForgeClientConfig>;
+    getForm(key: string, options?: FormForgeSchemaRequestOptions): Promise<FormForgeFormSchema>;
+    getFormVersions(key: string, options?: FormForgeSchemaRequestOptions): Promise<FormForgeSchemaVersionsResponse>;
+    getFormVersion(key: string, version: string, options?: FormForgeSchemaRequestOptions): Promise<FormForgeFormSchema>;
+    resolveForm(key: string, input?: FormForgeResolveInput, options?: FormForgeSubmitRequestOptions): Promise<FormForgeFormSchema>;
+    submitForm(key: string, input: FormForgeSubmitInput, options?: FormForgeSubmitRequestOptions): Promise<FormForgeSubmissionResponse>;
+    submitFormMultipart(key: string, formData: FormData, options?: FormForgeSubmitMultipartOptions): Promise<FormForgeSubmissionResponse>;
+    stageUpload(key: string, input: FormForgeStageUploadInput, options?: FormForgeSubmitRequestOptions): Promise<FormForgeStagedUploadResponse>;
+    saveDraft(key: string, input: FormForgeDraftSaveInput, options?: FormForgeDraftRequestOptions): Promise<FormForgeDraftResponse>;
+    getCurrentDraft(key: string, options?: FormForgeDraftRequestOptions): Promise<FormForgeDraftResponse>;
+    deleteCurrentDraft(key: string, options?: FormForgeDraftRequestOptions): Promise<FormForgeDraftResponse>;
+    listResponses(key: string, query?: Record<string, string | number | boolean | undefined>, options?: FormForgeResponsesRequestOptions): Promise<FormForgeResponsesListResponse>;
+    getResponse(key: string, submissionId: string, options?: FormForgeResponsesRequestOptions): Promise<FormForgeJsonObject>;
+    deleteResponse(key: string, submissionId: string, options?: FormForgeResponsesRequestOptions): Promise<FormForgeJsonObject>;
+    listForms(includeDeleted?: boolean, options?: FormForgeManagementRequestOptions): Promise<FormForgeManagementForm[]>;
+    createForm(input: FormForgeManagementCreateInput, options?: FormForgeMutationOptions): Promise<FormForgeManagementForm>;
+    patchForm(key: string, input: FormForgeManagementPatchInput, options?: FormForgeMutationOptions): Promise<FormForgeManagementForm>;
+    publishForm(key: string, options?: FormForgeMutationOptions): Promise<FormForgeManagementForm>;
+    unpublishForm(key: string, options?: FormForgeMutationOptions): Promise<FormForgeManagementForm>;
+    deleteForm(key: string, options?: FormForgeMutationOptions): Promise<FormForgeManagementForm>;
+    getRevisions(key: string, includeDeleted?: boolean, options?: FormForgeManagementRequestOptions): Promise<FormForgeRevisionSummary[]>;
+    getDiff(key: string, fromVersion: number, toVersion: number, options?: FormForgeManagementRequestOptions): Promise<FormForgeDiffResponse>;
+    listCategories(query?: FormForgeCategoryListQuery, options?: FormForgeCategoryRequestOptions): Promise<FormForgeCategoryListResponse>;
+    getCategory(categoryKey: string, options?: FormForgeCategoryRequestOptions): Promise<FormForgeCategory>;
+    createCategory(input: FormForgeCategoryCreateInput, options?: FormForgeMutationOptions): Promise<FormForgeCategory>;
+    patchCategory(categoryKey: string, input: FormForgeCategoryUpdateInput, options?: FormForgeMutationOptions): Promise<FormForgeCategory>;
+    deleteCategory(categoryKey: string, options?: FormForgeMutationOptions): Promise<FormForgeCategory>;
+}
+export declare function createFormForgeClient(config?: FormForgeClientConfig): FormForgeClient;
+//# sourceMappingURL=client.d.ts.map