convex-verify 1.1.0 → 1.2.2

package/README.md

@@ -24,36 +24,30 @@ pnpm install convex-verify
 ## Quick Start
 
 ```ts
-import {
-	defaultValuesConfig,
-	protectedColumnsConfig,
-	uniqueColumnConfig,
-	uniqueRowConfig,
-	verifyConfig,
-} from "convex-verify";
+import { verifyConfig } from "convex-verify";
 
 import schema from "./schema";
 
-export const { insert, patch, dangerouslyPatch } = verifyConfig(schema, {
-	defaultValues: defaultValuesConfig(schema, {
+export const { insert, patch, dangerouslyPatch, verify, config } = verifyConfig(schema, {
+	defaultValues: {
 		posts: { status: "draft", views: 0 },
-	}),
+	},
 
-	protectedColumns: protectedColumnsConfig(schema, {
+	protectedColumns: {
 		posts: ["authorId"],
-	}),
+	},
 
-	uniqueRow: uniqueRowConfig(schema, {
+	uniqueRow: {
 		posts: ["by_author_slug"],
-	}),
+	},
 
-	uniqueColumn: uniqueColumnConfig(schema, {
+	uniqueColumn: {
 		users: ["by_email", "by_username"],
-	}),
+	},
 });
 ```
 
-Then use in your mutations:
+Use the returned helpers in mutations:
 
 ```ts
 import { insert, patch } from "./verify";
@@ -82,48 +76,68 @@ export const updatePost = mutation({
 });
 ```
 
+And use the returned verifier surface directly when you need schema-aware built-in checks outside the insert/patch helpers:
+
+```ts
+await verify.uniqueRow(ctx, "posts", {
+	title: "Hello",
+	slug: "hello",
+	authorId: "author-1",
+});
+
+config.uniqueRow.posts; // typed configured options
+```
+
 ---
 
 ## API Reference
 
 ### `verifyConfig(schema, config)`
 
-Main configuration function that returns typed `insert`, `patch`, and `dangerouslyPatch` functions.
+Main configuration function. It accepts inline schema-aware config and returns typed mutation helpers plus a direct `verify` registry.
 
 ```ts
-const { insert, patch, dangerouslyPatch } = verifyConfig(schema, {
-  defaultValues?: DefaultValuesConfig,
-  protectedColumns?: ProtectedColumnsConfig,
-  uniqueRow?: UniqueRowConfig,
-  uniqueColumn?: UniqueColumnConfig,
+const { insert, patch, dangerouslyPatch, verify, config } = verifyConfig(schema, {
+  defaultValues?: {
+    posts?: { status?: "draft"; views?: number };
+  } | (() => { ... } | Promise<{ ... }>),
+  protectedColumns?: {
+    posts?: ["authorId"];
+  },
+  uniqueRow?: {
+    posts?: ["by_author_slug"];
+  },
+  uniqueColumn?: {
+    users?: ["by_email", "by_username"];
+  },
   extensions?: Extension[],
 });
 ```
 
 #### Returns
 
-| Function           | Description                                                                         |
+| Function/Value     | Description                                                                         |
 | ------------------ | ----------------------------------------------------------------------------------- |
 | `insert`           | Insert with default values applied and extensions run                               |
 | `patch`            | Patch with protected columns removed and extensions run                             |
 | `dangerouslyPatch` | Patch with full access to all columns (bypasses protected columns type restriction) |
+| `verify`           | Built-in verifier functions for configured features only                            |
+| `config`           | Passive typed snapshot of the built-in config that was passed in                    |
 
 ---
 
-## `defaultValuesConfig`
-
-Makes specified fields optional in `insert()` by providing default values. The types update automatically - fields with defaults become optional.
+## `defaultValues`
 
-```ts
-import { defaultValuesConfig } from "convex-verify";
-```
+Makes specified fields optional in `insert()` by providing default values. The types update automatically.
 
 ### Static Values
 
 ```ts
-const config = defaultValuesConfig(schema, {
+const { insert } = verifyConfig(schema, {
+	defaultValues: {
 	posts: { status: "draft", views: 0 },
 	comments: { likes: 0 },
+	},
 });
 ```
 
@@ -132,41 +146,58 @@ const config = defaultValuesConfig(schema, {
 Use a function when values should be generated fresh on each insert:
 
 ```ts
-const config = defaultValuesConfig(schema, () => ({
-	posts: {
-		status: "draft",
-		slug: generateRandomSlug(),
-		createdAt: Date.now(),
-	},
-}));
+const { insert } = verifyConfig(schema, {
+	defaultValues: () => ({
+		posts: {
+			status: "draft",
+			slug: generateRandomSlug(),
+			createdAt: Date.now(),
+		},
+	}),
+});
 ```
 
 ### Async Values
 
 ```ts
-const config = defaultValuesConfig(schema, async () => ({
-	posts: {
-		category: await fetchDefaultCategory(),
+const { insert } = verifyConfig(schema, {
+	defaultValues: async () => ({
+		posts: {
+			category: await fetchDefaultCategory(),
+		},
+	}),
+});
+```
+
+### Direct Verifier Calls
+
+```ts
+const { verify } = verifyConfig(schema, {
+	defaultValues: {
+		users: { status: "pending" },
 	},
-}));
+});
+
+const user = await verify.defaultValues("users", {
+	email: "alice@example.com",
+	username: "alice",
+});
 ```
 
 ---
 
-## `protectedColumnsConfig`
+## `protectedColumns`
 
 Removes specified columns from the `patch()` input type, preventing accidental updates to critical fields like `authorId` or `createdAt`.
 
-```ts
-import { protectedColumnsConfig } from "convex-verify";
-```
-
 ### Usage
 
 ```ts
-const config = protectedColumnsConfig(schema, {
-	posts: ["authorId", "createdAt"],
-	comments: ["postId", "authorId"],
+const { patch, dangerouslyPatch } = verifyConfig(schema, {
+	protectedColumns: {
+		posts: ["authorId", "createdAt"],
+		comments: ["postId", "authorId"],
+	},
 });
 ```
 
@@ -192,33 +223,33 @@ await dangerouslyPatch(ctx, "posts", id, {
 
 ---
 
-## `uniqueRowConfig`
+## `uniqueRow`
 
 Enforces uniqueness across multiple columns using composite indexes. Useful for things like "unique slug per author" or "unique name per organization".
 
-```ts
-import { uniqueRowConfig } from "convex-verify";
-```
-
 ### Usage
 
 ```ts
-const config = uniqueRowConfig(schema, {
-	posts: ["by_author_slug"], // Unique author + slug combination
-	projects: ["by_org_name"], // Unique org + name combination
+const { verify } = verifyConfig(schema, {
+	uniqueRow: {
+		posts: ["by_author_slug"], // Unique author + slug combination
+		projects: ["by_org_name"], // Unique org + name combination
+	},
 });
 ```
 
 ### With Options
 
 ```ts
-const config = uniqueRowConfig(schema, {
-	posts: [
-		{
-			index: "by_author_slug",
-			identifiers: ["_id", "authorId"], // Fields that identify "same document"
-		},
-	],
+const { verify } = verifyConfig(schema, {
+	uniqueRow: {
+		posts: [
+			{
+				index: "by_author_slug",
+				identifiers: ["_id", "authorId"], // Fields that identify "same document"
+			},
+		],
+	},
 });
 ```
 
@@ -226,20 +257,18 @@ The `identifiers` option controls which fields are checked when determining if a
 
 ---
 
-## `uniqueColumnConfig`
+## `uniqueColumn`
 
 Enforces uniqueness on single columns using indexes. Useful for email addresses, usernames, slugs, etc.
 
-```ts
-import { uniqueColumnConfig } from "convex-verify";
-```
-
 ### Usage
 
 ```ts
-const config = uniqueColumnConfig(schema, {
-	users: ["by_email", "by_username"],
-	organizations: ["by_slug"],
+const { verify } = verifyConfig(schema, {
+	uniqueColumn: {
+		users: ["by_email", "by_username"],
+		organizations: ["by_slug"],
+	},
 });
 ```
 
@@ -251,14 +280,43 @@ The column name is derived from the index name by removing the `by_` prefix:
 ### With Options
 
 ```ts
-const config = uniqueColumnConfig(schema, {
-	users: [
-		"by_username",
-		{ index: "by_email", identifiers: ["_id", "clerkId"] },
-	],
+const { verify } = verifyConfig(schema, {
+	uniqueColumn: {
+		users: [
+			"by_username",
+			{ index: "by_email", identifiers: ["_id", "clerkId"] },
+		],
+	},
 });
 ```
 
+### Direct Verifier Calls
+
+```ts
+await verify.uniqueColumn(ctx, "users", {
+	email: "alice@example.com",
+});
+```
+
+Patch checks use the document id:
+
+```ts
+await verify.uniqueColumn(ctx, "users", userId, {
+	username: "alice",
+});
+```
+
+Direct uniqueness verifier calls may use partial data. Only configured unique fields present in the payload are checked.
+
+### Breaking Change
+
+Version `2.0.0` removes the old helper-wrapper API:
+
+- `defaultValuesConfig`
+- `protectedColumnsConfig`
+- `uniqueRowConfig`
+- `uniqueColumnConfig`
+
 ---
 
 ## Custom Extensions
@@ -283,15 +341,25 @@ Custom extensions let you add your own validation and transformation logic that
 - `patch()` still strips protected columns at runtime; use `dangerouslyPatch()` if an extension must change them
 - Extension errors should use `ConvexError` for proper error handling on the client
 
+### Execution Order
+
+Custom extensions always run before built-in uniqueness checks.
+
+- `insert()`: `defaultValues` → custom `extensions` → `uniqueRow` → `uniqueColumn`
+- `patch()`: protected-column strip → custom `extensions` → `uniqueRow` → `uniqueColumn` → protected-column strip again
+- `dangerouslyPatch()`: custom `extensions` → `uniqueRow` → `uniqueColumn`
+
+`defaultValues` and protected-column stripping are preprocessing steps, not entries in the custom `extensions` array.
+
 ### Creating an Extension
 
-Use `createExtension`. If you want schema-aware typing in the callback, pass your schema type as the generic:
+Use `createExtension`. For schema-aware typing in the callback, pass the schema as the first argument:
 
 ```ts
 import { createExtension } from "convex-verify";
 import { ConvexError } from "convex/values";
 
-const normalizeEmail = createExtension<typeof schema>((input) => {
+const normalizeEmail = createExtension(schema, (input) => {
 	if (input.tableName !== "users") {
 		return input.data;
 	}

package/dist/core/index.d.mts

@@ -1,58 +1,17 @@
-import { GenericSchema, SchemaDefinition, TableNamesInDataModel, DataModelFromSchemaDefinition, DocumentByName, GenericMutationCtx, WithoutSystemFields } from 'convex/server';
-import { GenericId } from 'convex/values';
-import { S as SchemaExtension } from '../plugin-DlsboiCF.mjs';
-export { d as Extension, E as ExtensionContext, a as ExtensionInput, b as ExtensionInputForSchema, e as ExtensionRecord, c as createExtension, i as isExtension, r as runExtensions } from '../plugin-DlsboiCF.mjs';
-import { V as VerifyConfigInput, H as HasKey, M as MakeOptional, b as OptionalKeysForTable, a as OnFailCallback, d as ProtectedKeysForTable } from '../types-DvJMYubf.mjs';
-export { B as BaseConfigReturn, k as DMGeneric, D as DefaultValuesConfigData, l as DefaultValuesInput, E as ExtractDefaultValuesConfig, c as ExtractProtectedColumnsConfig, I as IndexConfigBaseOptions, j as IndexConfigEntry, N as NormalizedIndexConfig, O as OnFailArgs, P as Prettify, m as ProtectedColumnsInput, g as UniqueColumnConfigData, h as UniqueColumnConfigEntry, i as UniqueColumnConfigOptions, U as UniqueRowConfigData, e as UniqueRowConfigEntry, f as UniqueRowConfigOptions, n as normalizeIndexConfigEntry } from '../types-DvJMYubf.mjs';
+import { c as createExtension$1, i as isExtension$1, r as runExtensions$1 } from '../verifyConfig-Kn3Ikj00.mjs';
+export { d as Extension, E as ExtensionContext, a as ExtensionInput, b as ExtensionInputForSchema, e as ExtensionRecord, S as SchemaExtension, v as verifyConfig } from '../verifyConfig-Kn3Ikj00.mjs';
+export { v as BaseConfigReturn, B as BuiltinConfigKey, C as ConfigRegistry, w as DMGeneric, D as DataModelForSchema, c as DefaultValuesConfigData, d as DefaultValuesConfigInput, k as DefaultValuesVerifyFn, m as ExtensionStyleVerifyFn, E as ExtractDefaultValuesConfig, g as ExtractProtectedColumnsConfig, H as HasKey, I as IndexConfigBaseOptions, u as IndexConfigEntry, M as MakeOptional, a as MutationCtxForSchema, N as NormalizedIndexConfig, O as OnFailArgs, b as OnFailCallback, f as OptionalKeysForTable, P as Prettify, e as ProtectedColumnsConfigData, l as ProtectedColumnsVerifyFn, h as ProtectedKeysForTable, q as UniqueColumnConfigData, r as UniqueColumnConfigEntry, s as UniqueColumnConfigOptions, U as UniqueRowConfigData, o as UniqueRowConfigEntry, p as UniqueRowConfigOptions, V as VerifyConfigInput, i as VerifyInsertInput, j as VerifyPatchInput, n as VerifyRegistry, t as normalizeIndexConfigEntry } from '../types-B8ZkLuJ2.mjs';
+import 'convex/server';
+import 'convex/values';
 
-/**
- * Extended config input that includes optional extensions.
- */
-type VerifyConfigInputWithExtensions<S extends SchemaDefinition<GenericSchema, boolean>> = VerifyConfigInput & {
-    /**
-     * Unique row validation config.
-     * Enforces uniqueness across multiple columns using composite indexes.
-     *
-     * Can also be added to the `extensions` array.
-     */
-    uniqueRow?: SchemaExtension<S, "uniqueRow", any>;
-    /**
-     * Unique column validation config.
-     * Enforces uniqueness on single columns using indexes.
-     *
-     * Can also be added to the `extensions` array.
-     */
-    uniqueColumn?: SchemaExtension<S, "uniqueColumn", any>;
-    /**
-     * Additional extensions to run after transform configs (defaultValues, etc.).
-     * These extensions can validate data, transform/mutate it, or both.
-     * Custom extensions run before built-in uniqueness extensions so the built-ins
-     * validate the final transformed payload.
-     * Extensions run in order; each receives the (possibly transformed) output of the previous.
-     *
-     * Built-in extensions (uniqueRow, uniqueColumn) can be added here
-     * as an alternative to using their dedicated config keys when you need
-     * explicit ordering.
-     */
-    extensions?: SchemaExtension<S>[];
-};
-/**
- * Configure type-safe insert and patch functions with validation and transforms.
- *
- * @param schema - Your Convex schema definition
- * @param configs - Configuration object with transforms, configs, and extensions
- * @returns Object with `insert`, `patch`, and `dangerouslyPatch` functions
- */
-declare const verifyConfig: <S extends GenericSchema, SD extends SchemaDefinition<S, boolean>, const VC extends VerifyConfigInputWithExtensions<SD>>(_schema: SD, configs: VC) => {
-    insert: <const TN extends TableNamesInDataModel<DataModelFromSchemaDefinition<SD>>, const D extends DocumentByName<DataModelFromSchemaDefinition<SD>, TN>>(ctx: Omit<GenericMutationCtx<DataModelFromSchemaDefinition<SD>>, never>, tableName: TN, data: HasKey<VC, "defaultValues"> extends true ? MakeOptional<WithoutSystemFields<D>, OptionalKeysForTable<VC, TN> & keyof WithoutSystemFields<D>> : WithoutSystemFields<D>, options?: {
-        onFail?: OnFailCallback<D>;
-    }) => Promise<GenericId<TN>>;
-    patch: <const TN extends TableNamesInDataModel<DataModelFromSchemaDefinition<SD>>, const D_1 extends DocumentByName<DataModelFromSchemaDefinition<SD>, TN>>(ctx: Omit<GenericMutationCtx<DataModelFromSchemaDefinition<SD>>, never>, tableName: TN, id: GenericId<TN>, data: HasKey<VC, "protectedColumns"> extends true ? Omit<Partial<WithoutSystemFields<D_1>>, ProtectedKeysForTable<VC, TN> & keyof WithoutSystemFields<D_1>> : Partial<WithoutSystemFields<D_1>>, options?: {
-        onFail?: OnFailCallback<D_1>;
-    }) => Promise<void>;
-    dangerouslyPatch: <const TN extends TableNamesInDataModel<DataModelFromSchemaDefinition<SD>>, const D_2 extends DocumentByName<DataModelFromSchemaDefinition<SD>, TN>>(ctx: Omit<GenericMutationCtx<DataModelFromSchemaDefinition<SD>>, never>, tableName: TN, id: GenericId<TN>, data: Partial<WithoutSystemFields<D_2>>, options?: {
-        onFail?: OnFailCallback<D_2>;
-    }) => Promise<void>;
+type ProtectedColumnsLike = Record<string, readonly PropertyKey[] | undefined>;
+declare const stripProtectedPatchColumns: <T extends Record<string, any>>(protectedColumns: ProtectedColumnsLike, tableName: string, data: T) => {
+    filteredData: T;
+    removedColumns: string[];
 };
 
-export { HasKey, MakeOptional, OnFailCallback, OptionalKeysForTable, ProtectedKeysForTable, SchemaExtension, VerifyConfigInput, verifyConfig };
+declare const createExtension: typeof createExtension$1;
+declare const isExtension: typeof isExtension$1;
+declare const runExtensions: typeof runExtensions$1;
+
+export { createExtension, isExtension, runExtensions, stripProtectedPatchColumns };

package/dist/core/index.d.ts

@@ -1,58 +1,17 @@
-import { GenericSchema, SchemaDefinition, TableNamesInDataModel, DataModelFromSchemaDefinition, DocumentByName, GenericMutationCtx, WithoutSystemFields } from 'convex/server';
-import { GenericId } from 'convex/values';
-import { S as SchemaExtension } from '../plugin-BOb1Kw1A.js';
-export { d as Extension, E as ExtensionContext, a as ExtensionInput, b as ExtensionInputForSchema, e as ExtensionRecord, c as createExtension, i as isExtension, r as runExtensions } from '../plugin-BOb1Kw1A.js';
-import { V as VerifyConfigInput, H as HasKey, M as MakeOptional, b as OptionalKeysForTable, a as OnFailCallback, d as ProtectedKeysForTable } from '../types-DvJMYubf.js';
-export { B as BaseConfigReturn, k as DMGeneric, D as DefaultValuesConfigData, l as DefaultValuesInput, E as ExtractDefaultValuesConfig, c as ExtractProtectedColumnsConfig, I as IndexConfigBaseOptions, j as IndexConfigEntry, N as NormalizedIndexConfig, O as OnFailArgs, P as Prettify, m as ProtectedColumnsInput, g as UniqueColumnConfigData, h as UniqueColumnConfigEntry, i as UniqueColumnConfigOptions, U as UniqueRowConfigData, e as UniqueRowConfigEntry, f as UniqueRowConfigOptions, n as normalizeIndexConfigEntry } from '../types-DvJMYubf.js';
+import { c as createExtension$1, i as isExtension$1, r as runExtensions$1 } from '../verifyConfig-CTrtqMr_.js';
+export { d as Extension, E as ExtensionContext, a as ExtensionInput, b as ExtensionInputForSchema, e as ExtensionRecord, S as SchemaExtension, v as verifyConfig } from '../verifyConfig-CTrtqMr_.js';
+export { v as BaseConfigReturn, B as BuiltinConfigKey, C as ConfigRegistry, w as DMGeneric, D as DataModelForSchema, c as DefaultValuesConfigData, d as DefaultValuesConfigInput, k as DefaultValuesVerifyFn, m as ExtensionStyleVerifyFn, E as ExtractDefaultValuesConfig, g as ExtractProtectedColumnsConfig, H as HasKey, I as IndexConfigBaseOptions, u as IndexConfigEntry, M as MakeOptional, a as MutationCtxForSchema, N as NormalizedIndexConfig, O as OnFailArgs, b as OnFailCallback, f as OptionalKeysForTable, P as Prettify, e as ProtectedColumnsConfigData, l as ProtectedColumnsVerifyFn, h as ProtectedKeysForTable, q as UniqueColumnConfigData, r as UniqueColumnConfigEntry, s as UniqueColumnConfigOptions, U as UniqueRowConfigData, o as UniqueRowConfigEntry, p as UniqueRowConfigOptions, V as VerifyConfigInput, i as VerifyInsertInput, j as VerifyPatchInput, n as VerifyRegistry, t as normalizeIndexConfigEntry } from '../types-B8ZkLuJ2.js';
+import 'convex/server';
+import 'convex/values';
 
-/**
- * Extended config input that includes optional extensions.
- */
-type VerifyConfigInputWithExtensions<S extends SchemaDefinition<GenericSchema, boolean>> = VerifyConfigInput & {
-    /**
-     * Unique row validation config.
-     * Enforces uniqueness across multiple columns using composite indexes.
-     *
-     * Can also be added to the `extensions` array.
-     */
-    uniqueRow?: SchemaExtension<S, "uniqueRow", any>;
-    /**
-     * Unique column validation config.
-     * Enforces uniqueness on single columns using indexes.
-     *
-     * Can also be added to the `extensions` array.
-     */
-    uniqueColumn?: SchemaExtension<S, "uniqueColumn", any>;
-    /**
-     * Additional extensions to run after transform configs (defaultValues, etc.).
-     * These extensions can validate data, transform/mutate it, or both.
-     * Custom extensions run before built-in uniqueness extensions so the built-ins
-     * validate the final transformed payload.
-     * Extensions run in order; each receives the (possibly transformed) output of the previous.
-     *
-     * Built-in extensions (uniqueRow, uniqueColumn) can be added here
-     * as an alternative to using their dedicated config keys when you need
-     * explicit ordering.
-     */
-    extensions?: SchemaExtension<S>[];
-};
-/**
- * Configure type-safe insert and patch functions with validation and transforms.
- *
- * @param schema - Your Convex schema definition
- * @param configs - Configuration object with transforms, configs, and extensions
- * @returns Object with `insert`, `patch`, and `dangerouslyPatch` functions
- */
-declare const verifyConfig: <S extends GenericSchema, SD extends SchemaDefinition<S, boolean>, const VC extends VerifyConfigInputWithExtensions<SD>>(_schema: SD, configs: VC) => {
-    insert: <const TN extends TableNamesInDataModel<DataModelFromSchemaDefinition<SD>>, const D extends DocumentByName<DataModelFromSchemaDefinition<SD>, TN>>(ctx: Omit<GenericMutationCtx<DataModelFromSchemaDefinition<SD>>, never>, tableName: TN, data: HasKey<VC, "defaultValues"> extends true ? MakeOptional<WithoutSystemFields<D>, OptionalKeysForTable<VC, TN> & keyof WithoutSystemFields<D>> : WithoutSystemFields<D>, options?: {
-        onFail?: OnFailCallback<D>;
-    }) => Promise<GenericId<TN>>;
-    patch: <const TN extends TableNamesInDataModel<DataModelFromSchemaDefinition<SD>>, const D_1 extends DocumentByName<DataModelFromSchemaDefinition<SD>, TN>>(ctx: Omit<GenericMutationCtx<DataModelFromSchemaDefinition<SD>>, never>, tableName: TN, id: GenericId<TN>, data: HasKey<VC, "protectedColumns"> extends true ? Omit<Partial<WithoutSystemFields<D_1>>, ProtectedKeysForTable<VC, TN> & keyof WithoutSystemFields<D_1>> : Partial<WithoutSystemFields<D_1>>, options?: {
-        onFail?: OnFailCallback<D_1>;
-    }) => Promise<void>;
-    dangerouslyPatch: <const TN extends TableNamesInDataModel<DataModelFromSchemaDefinition<SD>>, const D_2 extends DocumentByName<DataModelFromSchemaDefinition<SD>, TN>>(ctx: Omit<GenericMutationCtx<DataModelFromSchemaDefinition<SD>>, never>, tableName: TN, id: GenericId<TN>, data: Partial<WithoutSystemFields<D_2>>, options?: {
-        onFail?: OnFailCallback<D_2>;
-    }) => Promise<void>;
+type ProtectedColumnsLike = Record<string, readonly PropertyKey[] | undefined>;
+declare const stripProtectedPatchColumns: <T extends Record<string, any>>(protectedColumns: ProtectedColumnsLike, tableName: string, data: T) => {
+    filteredData: T;
+    removedColumns: string[];
 };
 
-export { HasKey, MakeOptional, OnFailCallback, OptionalKeysForTable, ProtectedKeysForTable, SchemaExtension, VerifyConfigInput, verifyConfig };
+declare const createExtension: typeof createExtension$1;
+declare const isExtension: typeof isExtension$1;
+declare const runExtensions: typeof runExtensions$1;
+
+export { createExtension, isExtension, runExtensions, stripProtectedPatchColumns };