@tinacms/schema-tools 0.0.1 → 0.0.4

package/CHANGELOG.md

@@ -0,0 +1,47 @@
+# @tinacms/schema-tools
+
+## 0.0.4
+
+### Patch Changes
+
+- 6e2ed31a2: Added `isTitle` property to the schema that allows the title to be displayed in the CMS
+
+## 0.0.3
+
+### Patch Changes
+
+- 921709a7e: Adds validation to the schema instead of only using typescript types
+
+## 0.0.2
+
+### Patch Changes
+
+- abf25c673: The schema can now to used on the frontend (optional for now but will be the main path moving forward).
+
+  ### How to migrate.
+
+  If you gone though the `tinacms init` process there should be a file called `.tina/components/TinaProvider`. In that file you can import the schema from `schema.ts` and add it to the TinaCMS wrapper component.
+
+  ```tsx
+  import TinaCMS from 'tinacms'
+  import schema, { tinaConfig } from '../schema.ts'
+
+  // Importing the TinaProvider directly into your page will cause Tina to be added to the production bundle.
+  // Instead, import the tina/provider/index default export to have it dynamially imported in edit-moode
+  /**
+   *
+   * @private Do not import this directly, please import the dynamic provider instead
+   */
+  const TinaProvider = ({ children }) => {
+    return (
+      <TinaCMS {...tinaConfig} schema={schema}>
+        {children}
+      </TinaCMS>
+    )
+  }
+
+  export default TinaProvider
+  ```
+
+- 801f39f62: Update types
+- e8b0de1f7: Add `parentTypename` to fields to allow us to disambiguate between fields which have the same field names but different types. Example, an event from field name of `blocks.0.title` could belong to a `Cta` block or a `Hero` block, both of which have a `title` field.

package/dist/index.d.ts

@@ -12,3 +12,4 @@ limitations under the License.
 */
 export * from './schema';
 export * from './types';
+export * from './validate';

package/dist/index.js

@@ -36,8 +36,8 @@ var __objRest = (source, exclude) => {
 };
 var __export = (target, all) => {
   __markAsModule(target);
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __reExport = (target, module2, desc) => {
   if (module2 && typeof module2 === "object" || typeof module2 === "function") {
@@ -54,9 +54,11 @@ var __toModule = (module2) => {
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/index.ts
 __export(exports, {
   TinaSchema: () => TinaSchema,
+  TinaSchemaValidationError: () => TinaSchemaValidationError,
   addNamespaceToSchema: () => addNamespaceToSchema,
   resolveField: () => resolveField,
-  resolveForm: () => resolveForm
+  resolveForm: () => resolveForm,
+  validateSchema: () => validateSchema
 });
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/schema/addNamespaceToSchema.ts
@@ -170,10 +172,24 @@ var NAMER = {
   }
 };
 
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/util/hasDuplicates.ts
+function hasDuplicates(array) {
+  if (!array) {
+    return false;
+  } else {
+    return new Set(array).size !== array.length;
+  }
+}
+
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/schema/TinaSchema.ts
 var TinaSchema = class {
   constructor(config) {
     this.config = config;
+    this.getIsTitleFieldName = (collection) => {
+      const col = this.getCollection(collection);
+      const field = col == null ? void 0 : col.fields.find((x) => x.type === "string" && x.isTitle);
+      return field == null ? void 0 : field.name;
+    };
     this.getCollectionsByName = (collectionNames) => {
       return this.schema.collections.filter((collection) => collectionNames.includes(collection.name));
     };
@@ -319,6 +335,7 @@ var TinaSchema = class {
 var resolveField = (_a, schema) => {
   var _b = _a, { namespace } = _b, field = __objRest(_b, ["namespace"]);
   var _a2;
+  field.parentTypename = NAMER.dataTypeName(namespace.filter((_, i) => i < namespace.length - 1));
   const extraFields = field.ui || {};
   switch (field.type) {
     case "number":
@@ -444,10 +461,286 @@ var resolveForm = ({
     })
   };
 };
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/index.ts
+var import_zod4 = __toModule(require("zod"));
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/util/parseZodErrors.ts
+var parseZodError = ({ zodError }) => {
+  var _a;
+  const errors = zodError.flatten((issue) => {
+    const moreInfo = [];
+    if (issue.code === "invalid_union") {
+      issue.unionErrors.map((unionError) => {
+        moreInfo.push(parseZodError({ zodError: unionError }));
+      });
+    }
+    const errorMessage = `Error ${issue == null ? void 0 : issue.message} at path ${issue.path.join(".")}`;
+    const errorMessages = [errorMessage, ...moreInfo];
+    return {
+      errors: errorMessages
+    };
+  });
+  const formErrors = errors.formErrors.flatMap((x) => x.errors);
+  const parsedErrors = [
+    ...((_a = errors.fieldErrors) == null ? void 0 : _a.collections.flatMap((x) => x.errors)) || [],
+    ...formErrors
+  ];
+  return parsedErrors;
+};
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/schema.ts
+var import_zod3 = __toModule(require("zod"));
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/properties.ts
+var import_zod = __toModule(require("zod"));
+var name = import_zod.z.string({
+  required_error: "Name is required but not provided",
+  invalid_type_error: "Name must be a string"
+});
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/fields.ts
+var import_zod2 = __toModule(require("zod"));
+var TypeName = [
+  "string",
+  "boolean",
+  "number",
+  "datetime",
+  "image",
+  "object",
+  "reference",
+  "rich-text"
+];
+var typeTypeError = `type must be one of ${TypeName.join(", ")}`;
+var typeRequiredError = `type is required and must be one of ${TypeName.join(", ")}`;
+var nameProp = import_zod2.z.string({
+  required_error: "name must be provided",
+  invalid_type_error: "name must be a sting"
+});
+var Option = import_zod2.z.union([import_zod2.z.string(), import_zod2.z.object({ label: import_zod2.z.string(), value: import_zod2.z.string() })], {
+  errorMap: () => {
+    return {
+      message: "Invalid option array. Must be a string[] or {label: string, value: string}[]"
+    };
+  }
+});
+var TinaField = import_zod2.z.object({
+  name: nameProp,
+  label: import_zod2.z.string().optional(),
+  description: import_zod2.z.string().optional(),
+  required: import_zod2.z.boolean().optional()
+});
+var FieldWithList = TinaField.extend({ list: import_zod2.z.boolean().optional() });
+var TinaScalerBase = FieldWithList.extend({
+  options: import_zod2.z.array(Option).optional()
+});
+var StringField = TinaScalerBase.extend({
+  type: import_zod2.z.literal("string", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  }),
+  isTitle: import_zod2.z.boolean().optional()
+});
+var BooleanField = TinaScalerBase.extend({
+  type: import_zod2.z.literal("boolean", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+var NumberField = TinaScalerBase.extend({
+  type: import_zod2.z.literal("number", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+var ImageField = TinaScalerBase.extend({
+  type: import_zod2.z.literal("image", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+var DateTimeField = TinaScalerBase.extend({
+  type: import_zod2.z.literal("datetime", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  }),
+  dateFormat: import_zod2.z.string().optional(),
+  timeFormat: import_zod2.z.string().optional()
+});
+var ReferenceField = FieldWithList.extend({
+  type: import_zod2.z.literal("reference", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+var TinaFieldZod = import_zod2.z.lazy(() => {
+  const TemplateTemp = import_zod2.z.object({
+    label: import_zod2.z.string(),
+    name: nameProp,
+    fields: import_zod2.z.array(TinaFieldZod)
+  }).refine((val) => {
+    var _a;
+    return !hasDuplicates((_a = val.fields) == null ? void 0 : _a.map((x) => x.name));
+  }, {
+    message: "Fields must have a unique name"
+  });
+  const ObjectField = FieldWithList.extend({
+    type: import_zod2.z.literal("object", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    }),
+    fields: import_zod2.z.array(TinaFieldZod).min(1).optional().refine((val) => !hasDuplicates(val == null ? void 0 : val.map((x) => x.name)), {
+      message: "Fields must have a unique name"
+    }),
+    templates: import_zod2.z.array(TemplateTemp).min(1).optional().refine((val) => !hasDuplicates(val == null ? void 0 : val.map((x) => x.name)), {
+      message: "Templates must have a unique name"
+    })
+  });
+  const RichTextField = FieldWithList.extend({
+    type: import_zod2.z.literal("rich-text", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    }),
+    templates: import_zod2.z.array(TemplateTemp).optional().refine((val) => !hasDuplicates(val == null ? void 0 : val.map((x) => x.name)), {
+      message: "Templates must have a unique name"
+    })
+  });
+  return import_zod2.z.discriminatedUnion("type", [
+    StringField,
+    BooleanField,
+    NumberField,
+    ImageField,
+    DateTimeField,
+    ReferenceField,
+    ObjectField,
+    RichTextField
+  ], {
+    errorMap: (issue, ctx) => {
+      var _a;
+      if (issue.code === "invalid_union_discriminator") {
+        return {
+          message: `Invalid \`type\` property. In the schema is 'type: ${(_a = ctx.data) == null ? void 0 : _a.type}' and expected one of ${TypeName.join(", ")}`
+        };
+      }
+      return {
+        message: issue.message
+      };
+    }
+  }).superRefine((val, ctx) => {
+    if (val.type === "string") {
+      if (val.isTitle) {
+        if (val.list) {
+          ctx.addIssue({
+            code: import_zod2.z.ZodIssueCode.custom,
+            message: "You can not have `list: true` when using `isTitle`"
+          });
+        }
+        if (!val.required) {
+          ctx.addIssue({
+            code: import_zod2.z.ZodIssueCode.custom,
+            message: "You must have { required: true } when using `isTitle`"
+          });
+        }
+      }
+    }
+    if (val.type === "object") {
+      const message = "Must provide one of templates or fields in your collection";
+      let isValid = Boolean(val == null ? void 0 : val.templates) || Boolean(val == null ? void 0 : val.fields);
+      if (!isValid) {
+        ctx.addIssue({
+          code: import_zod2.z.ZodIssueCode.custom,
+          message
+        });
+        return false;
+      } else {
+        isValid = !((val == null ? void 0 : val.templates) && (val == null ? void 0 : val.fields));
+        if (!isValid) {
+          ctx.addIssue({
+            code: import_zod2.z.ZodIssueCode.custom,
+            message
+          });
+        }
+        return isValid;
+      }
+    }
+    return true;
+  });
+});
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/schema.ts
+var FORMATS = ["json", "md", "markdown", "mdx"];
+var Template = import_zod3.z.object({
+  label: import_zod3.z.string({
+    invalid_type_error: "label must be a string",
+    required_error: "label was not provided but is required"
+  }),
+  name,
+  fields: import_zod3.z.array(TinaFieldZod)
+}).refine((val) => {
+  var _a;
+  return !hasDuplicates((_a = val.fields) == null ? void 0 : _a.map((x) => x.name));
+}, {
+  message: "Fields must have a unique name"
+});
+var TinaCloudCollectionBase = import_zod3.z.object({
+  label: import_zod3.z.string().optional(),
+  name,
+  format: import_zod3.z.enum(FORMATS).optional()
+});
+var TinaCloudCollection = TinaCloudCollectionBase.extend({
+  fields: import_zod3.z.array(TinaFieldZod).min(1).optional().refine((val) => !hasDuplicates(val == null ? void 0 : val.map((x) => x.name)), {
+    message: "Fields must have a unique name"
+  }).refine((val) => {
+    const arr = (val == null ? void 0 : val.filter((x) => x.type === "string" && x.isTitle)) || [];
+    return arr.length < 2;
+  }, {
+    message: "Fields can only have one use of `isTitle`"
+  }),
+  templates: import_zod3.z.array(Template).min(1).optional().refine((val) => !hasDuplicates(val == null ? void 0 : val.map((x) => x.name)), {
+    message: "Templates must have a unique name"
+  })
+}).refine((val) => {
+  let isValid = Boolean(val == null ? void 0 : val.templates) || Boolean(val == null ? void 0 : val.fields);
+  if (!isValid) {
+    return false;
+  } else {
+    isValid = !((val == null ? void 0 : val.templates) && (val == null ? void 0 : val.fields));
+    return isValid;
+  }
+}, { message: "Must provide one of templates or fields in your collection" });
+var TinaCloudSchemaZod = import_zod3.z.object({
+  collections: import_zod3.z.array(TinaCloudCollection)
+}).refine((val) => !hasDuplicates(val.collections.map((x) => x.name)), {
+  message: "can not have two collections with the same name"
+});
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/index.ts
+var TinaSchemaValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TinaSchemaValidationError";
+  }
+};
+var validateSchema = ({
+  config
+}) => {
+  try {
+    TinaCloudSchemaZod.parse(config);
+  } catch (e) {
+    if (e instanceof import_zod4.ZodError) {
+      const errors = parseZodError({ zodError: e });
+      throw new TinaSchemaValidationError(errors.join(", \n"));
+    } else {
+      throw new Error(e);
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TinaSchema,
+  TinaSchemaValidationError,
   addNamespaceToSchema,
   resolveField,
-  resolveForm
+  resolveForm,
+  validateSchema
 });

package/dist/schema/TinaSchema.d.ts

@@ -41,6 +41,7 @@ export declare class TinaSchema {
         version?: Version;
         meta?: Meta;
     } & TinaCloudSchemaBase);
+    getIsTitleFieldName: (collection: string) => string;
     getCollectionsByName: (collectionNames: string[]) => TinaCloudCollection<true>[];
     getAllCollectionPaths: () => string[];
     getCollection: (collectionName: string) => TinaCloudCollection<true>;

package/dist/types/SchemaTypes.d.ts

@@ -61,18 +61,24 @@ export interface CollectionTemplatesWithNamespace<WithNamespace extends boolean>
 }
 declare type CollectionFields<WithNamespace extends boolean> = WithNamespace extends true ? CollectionFieldsWithNamespace<WithNamespace> : CollectionFieldsInner<WithNamespace>;
 export interface CollectionFieldsWithNamespace<WithNamespace extends boolean> extends BaseCollection {
-    fields: string | TinaFieldInner<WithNamespace>[];
+    fields: TinaFieldInner<WithNamespace>[];
     templates?: undefined;
     references?: ReferenceType<WithNamespace>[];
     namespace: string[];
 }
 interface CollectionFieldsInner<WithNamespace extends boolean> extends BaseCollection {
-    fields: string | TinaFieldInner<WithNamespace>[];
+    fields: TinaFieldInner<WithNamespace>[];
     templates?: undefined;
 }
 export declare type TinaFieldInner<WithNamespace extends boolean> = ScalarType<WithNamespace> | ObjectType<WithNamespace> | ReferenceType<WithNamespace> | RichType<WithNamespace>;
 export declare type TinaFieldBase = TinaFieldInner<false>;
-export declare type TinaFieldEnriched = TinaFieldInner<true>;
+export declare type TinaFieldEnriched = TinaFieldInner<true> & {
+    /**
+     * The parentTypename will always be an object type, either the type of a
+     * collection (ie. `Post`) or of an object field (ie. `PageBlocks`).
+     */
+    parentTypename?: string;
+};
 interface TinaField {
     name: string;
     label?: string;
@@ -83,7 +89,7 @@ interface TinaField {
      * NOTE: only serializable values are supported, so functions like `validate`
      * will be ignored.
      */
-    ui?: object;
+    ui?: Record<string, any>;
 }
 declare type ScalarType<WithNamespace extends boolean> = WithNamespace extends true ? ScalarTypeWithNamespace : ScalarTypeInner;
 declare type Option = string | {
@@ -102,11 +108,13 @@ declare type StringField = {
     type: 'string';
     isBody?: boolean;
     list?: false;
+    isTitle?: boolean;
     ui?: UIField<any, string>;
 } | {
     type: 'string';
     isBody?: boolean;
     list: true;
+    isTitle?: never;
     ui?: UIField<any, string[]>;
 };
 declare type BooleanField = {
@@ -159,6 +167,7 @@ export interface ReferenceTypeInner extends TinaField {
         name: string;
     };
     collections: string[];
+    ui?: UIField<any, string[]>;
 }
 export interface ReferenceTypeWithNamespace extends TinaField {
     type: 'reference';
@@ -169,6 +178,7 @@ export interface ReferenceTypeWithNamespace extends TinaField {
         name: string;
     };
     namespace: string[];
+    ui?: UIField<any, string[]>;
 }
 export interface RichTypeWithNamespace extends TinaField {
     type: 'rich-text';

package/dist/util/hasDuplicates.d.ts

@@ -0,0 +1,13 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export declare function hasDuplicates<T = any>(array: T[]): boolean;

package/dist/util/index.d.ts

@@ -14,3 +14,4 @@ export * from './validate';
 export * from './lastItem';
 export * from './namer';
 export * from './sequential';
+export * from './hasDuplicates';

package/dist/util/parseZodErrors.d.ts

@@ -0,0 +1,16 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import type { ZodError } from 'zod';
+export declare const parseZodError: ({ zodError }: {
+    zodError: ZodError;
+}) => string[];

package/dist/util/validate.d.ts

@@ -11,5 +11,5 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import * as yup from 'yup';
-import type { Schema } from 'yup';
-export declare function assertShape<T extends unknown>(value: unknown, yupSchema: (args: typeof yup) => Schema<any, any>, errorMessage?: string): asserts value is T;
+import type { AnySchema } from 'yup';
+export declare function assertShape<T extends unknown>(value: unknown, yupSchema: (args: typeof yup) => AnySchema, errorMessage?: string): asserts value is T;

package/dist/validate/fields.d.ts

@@ -0,0 +1,15 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { z } from 'zod';
+import { TinaFieldInner } from '../types/SchemaTypes';
+export declare const TinaFieldZod: z.ZodType<TinaFieldInner<false>>;

package/dist/validate/index.d.ts

@@ -0,0 +1,19 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { TinaCloudSchema } from '../types';
+export declare class TinaSchemaValidationError extends Error {
+    constructor(message: any);
+}
+export declare const validateSchema: ({ config, }: {
+    config: TinaCloudSchema<false>;
+}) => void;

package/dist/validate/properties.d.ts

@@ -0,0 +1,14 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { z } from 'zod';
+export declare const name: z.ZodString;

package/dist/validate/schema.d.ts

@@ -0,0 +1,139 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { z } from 'zod';
+export declare const TinaCloudSchemaZod: z.ZodEffects<z.ZodObject<{
+    collections: z.ZodArray<z.ZodEffects<z.ZodObject<z.extendShape<{
+        label: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        format: z.ZodOptional<z.ZodEnum<["json", "md", "markdown", "mdx"]>>;
+    }, {
+        fields: z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodArray<z.ZodType<import("..").TinaFieldInner<false>, z.ZodTypeDef, import("..").TinaFieldInner<false>>, "many">>, import("..").TinaFieldInner<false>[], import("..").TinaFieldInner<false>[]>, import("..").TinaFieldInner<false>[], import("..").TinaFieldInner<false>[]>;
+        templates: z.ZodEffects<z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+            label: z.ZodString;
+            name: z.ZodString;
+            fields: z.ZodArray<z.ZodType<import("..").TinaFieldInner<false>, z.ZodTypeDef, import("..").TinaFieldInner<false>>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }, {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }>, {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }, {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }>, "many">>, {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[], {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[]>;
+    }>, "strip", z.ZodTypeAny, {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }, {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }>, {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }, {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    collections?: {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }[];
+}, {
+    collections?: {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }[];
+}>, {
+    collections?: {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }[];
+}, {
+    collections?: {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }[];
+}>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/schema-tools",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -20,7 +20,8 @@
     "@types/yup": "^0.29.10",
     "jest": "^27.0.6",
     "react": "16.14.0",
-    "typescript": "^4.3.5"
+    "typescript": "^4.3.5",
+    "yup": "^0.32.0"
   },
   "peerDependencies": {
     "react": ">=16.14.0",
@@ -39,5 +40,8 @@
   "repository": {
     "url": "https://github.com/tinacms/tinacms.git",
     "directory": "packages/@tinacms/cli"
+  },
+  "dependencies": {
+    "zod": "^3.14.3"
   }
 }