prismic-ts-codegen 0.1.6 → 0.1.8

package/dist/index.cjs

@@ -1,1087 +1,7 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const tsMorph = require('ts-morph');
-const types = require('@prismicio/types');
-const pascalCase$1 = require('pascal-case');
-
-const BLANK_LINE_IDENTIFIER = "// ___BLANK_LINE_TO_BE_REPLACED___";
-const CUSTOM_TYPES_DOCUMENTATION_URL = "https://prismic.io/docs/core-concepts/custom-types";
-const SHARED_SLICES_DOCUMENTATION_URL = "https://prismic.io/docs/core-concepts/reusing-slices";
-const FIELD_DOCUMENTATION_URLS = {
-  UID: "https://prismic.io/docs/core-concepts/uid",
-  Boolean: "https://prismic.io/docs/core-concepts/boolean",
-  Color: "https://prismic.io/docs/core-concepts/color",
-  Date: "https://prismic.io/docs/core-concepts/date",
-  Timestamp: "https://prismic.io/docs/core-concepts/timestamp",
-  Number: "https://prismic.io/docs/core-concepts/number",
-  Text: "https://prismic.io/docs/core-concepts/key-text",
-  Select: "https://prismic.io/docs/core-concepts/select",
-  StructuredText: "https://prismic.io/docs/core-concepts/rich-text-title",
-  Image: "https://prismic.io/docs/core-concepts/image",
-  Link: "https://prismic.io/docs/core-concepts/link-content-relationship",
-  Embed: "https://prismic.io/docs/core-concepts/embed",
-  GeoPoint: "https://prismic.io/docs/core-concepts/geopoint",
-  Group: "https://prismic.io/docs/core-concepts/group",
-  IntegrationFields: "https://prismic.io/docs/core-concepts/integration-fields",
-  Slices: "https://prismic.io/docs/core-concepts/slices",
-  LegacySlices: "https://prismic.io/docs/core-concepts/slices"
-};
-
-const isCustomTypeModelField = (model) => {
-  return typeof model === "object" && model !== null && "type" in model;
-};
-
-const hasOwnProperty = (obj, prop) => {
-  return obj.hasOwnProperty(prop);
-};
-
-const isCustomTypeModelSlice = (model) => {
-  return typeof model === "object" && model !== null && hasOwnProperty(model, "type") && model.type === types.CustomTypeModelSliceType.Slice;
-};
-
-const isSharedSliceModel = (model) => {
-  return typeof model === "object" && model !== null && hasOwnProperty(model, "type") && model.type === types.CustomTypeModelSliceType.SharedSlice;
-};
-
-const getAPIIDPath = (config) => {
-  return config.path.map((element, i) => {
-    if (isCustomTypeModelField(element.model) && (element.model.type === types.CustomTypeModelFieldType.Group || element.model.type === types.CustomTypeModelFieldType.Slices)) {
-      return `${element.id}[]`;
-    } else {
-      if (element.id === "items") {
-        const previousElement = config.path[i - 1];
-        if (isCustomTypeModelSlice(previousElement.model) || isSharedSliceModel(previousElement.model)) {
-          return `${element.id}[]`;
-        }
-      }
-      return element.id;
-    }
-  }).join(".");
-};
-
-const getFieldDocumentationURL = (config) => {
-  return FIELD_DOCUMENTATION_URLS[config.model.type];
-};
-
-const isCustomTypeModel = (model) => {
-  return typeof model === "object" && model !== null && "json" in model;
-};
-
-const getHumanReadableModelName = (config) => {
-  if (isCustomTypeModel(config.model)) {
-    return config.model.label || config.model.id;
-  } else if (isSharedSliceModel(config.model)) {
-    return config.model.name;
-  } else if (isCustomTypeModelField(config.model)) {
-    if (config.model.config && "label" in config.model.config) {
-      return config.model.config.label || config.id;
-    } else if (config.model.config && "fieldset" in config.model) {
-      return config.model.fieldset || config.id;
-    }
-  } else if (isCustomTypeModelSlice(config.model)) {
-    return config.model.fieldset || config.id;
-  }
-  return `\`${config.id}\``;
-};
-
-const getHumanReadableFieldPath = (config) => {
-  return config.path.map((element) => {
-    if (element.label) {
-      return element.label;
-    } else if (element.model) {
-      return getHumanReadableModelName({
-        id: element.id,
-        model: element.model
-      });
-    } else {
-      return element.id;
-    }
-  }).join(" \u2192 ");
-};
-
-const getHumanReadableFieldType = (config) => {
-  switch (config.model.type) {
-    case "StructuredText": {
-      const isTitleField = config.model.config && "single" in config.model.config && config.model.config.single && config.model.config.single.split(",").every((blockType) => /heading/.test(blockType));
-      return isTitleField ? "Title" : "Rich Text";
-    }
-    case "IntegrationFields": {
-      const catalog = config.model.config?.catalog;
-      return `Integration Fields (Catalog: ${catalog ? `\`${catalog}\`` : "*unknown*"})`;
-    }
-    case "Link": {
-      switch (config.model.config?.select) {
-        case types.CustomTypeModelLinkSelectType.Document: {
-          return "Content Relationship";
-        }
-        case types.CustomTypeModelLinkSelectType.Media: {
-          return "Link to Media";
-        }
-        default: {
-          return "Link";
-        }
-      }
-    }
-    case "Slices": {
-      return "Slice Zone";
-    }
-    default: {
-      return config.model.type;
-    }
-  }
-};
-
-const writeFieldDocsDescription = (config) => {
-  if (config.description) {
-    config.writer.writeLine(config.description);
-  }
-  config.writer.blankLineIfLastNot();
-  if (config.fieldType) {
-    config.writer.writeLine(`- **Field Type**: ${config.fieldType}`);
-  }
-  if (config.placeholder) {
-    config.writer.writeLine(`- **Placeholder**: ${config.placeholder}`);
-  }
-  if (config.defaultValue !== void 0) {
-    const stringifiedDefaultValue = typeof config.defaultValue === "boolean" ? `${config.defaultValue}` : config.defaultValue;
-    config.writer.writeLine(`- **Default Value**: ${stringifiedDefaultValue}`);
-  }
-  if (config.apiIDPath) {
-    config.writer.writeLine(`- **API ID Path**: ${config.apiIDPath}`);
-  }
-  if (config.tabName) {
-    config.writer.writeLine(`- **Tab**: ${config.tabName}`);
-  }
-  if (config.documentationURL) {
-    config.writer.writeLine(`- **Documentation**: ${config.documentationURL}`);
-  }
-};
-
-const buildFieldDocs = (config) => {
-  return [
-    {
-      description: (writer) => {
-        const name = getHumanReadableModelName({
-          id: config.id,
-          model: config.model
-        });
-        const humanReadablePath = getHumanReadableFieldPath({
-          path: config.path
-        });
-        const fieldType = getHumanReadableFieldType({
-          model: config.model
-        });
-        const placeholder = config.model.config && "placeholder" in config.model.config && config.model.config.placeholder ? config.model.config.placeholder : `*None*`;
-        const defaultValue = config.model.config && "default_value" in config.model.config ? config.model.config.default_value : void 0;
-        const apiIDPath = getAPIIDPath({
-          path: [...config.path, { id: config.id, model: config.model }]
-        });
-        writeFieldDocsDescription({
-          writer,
-          description: `${name} field in *${humanReadablePath}*`,
-          fieldType,
-          placeholder,
-          defaultValue,
-          apiIDPath,
-          tabName: config.tabName,
-          documentationURL: getFieldDocumentationURL({ model: config.model })
-        });
-      }
-    }
-  ];
-};
-
-const pascalCase = (input) => pascalCase$1.pascalCase(input, {
-  transform: pascalCase$1.pascalCaseTransformMerge
-});
-
-const buildSharedSliceInterfaceNamePart = (config) => {
-  return pascalCase(`${config.id} Slice`);
-};
-
-const buildTypeName = (...parts) => {
-  let name = pascalCase(parts.filter(Boolean).join(" "));
-  if (/^[0-9]/.test(name) ? "_" : "") {
-    name = `_${name}`;
-  }
-  return name;
-};
-
-const addInterfacePropertyForField = (config) => {
-  switch (config.model.type) {
-    case "UID": {
-      break;
-    }
-    case "Boolean": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.BooleanField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Color": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.ColorField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Date": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.DateField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Embed": {
-      const providerTypes = [];
-      if (config.fieldConfigs.embed?.providerTypes) {
-        for (const providerType in config.fieldConfigs.embed?.providerTypes) {
-          const configuredProviderType = config.fieldConfigs.embed?.providerTypes[providerType];
-          providerTypes.push(
-            `({ provider_name: "${providerType}" } & ${configuredProviderType})`
-          );
-        }
-      }
-      config.interface.addProperty({
-        name: config.id,
-        type: providerTypes.length > 0 ? `prismicT.EmbedField<prismicT.AnyOEmbed & prismicT.OEmbedExtra & (${providerTypes.join(
-          " | "
-        )})>` : "prismicT.EmbedField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "GeoPoint": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.GeoPointField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Image": {
-      if (config.model.config?.thumbnails && config.model.config.thumbnails.length > 0) {
-        const thumbnailNames = config.model.config.thumbnails.map((thumbnail) => `"${thumbnail.name}"`).join(" | ");
-        config.interface.addProperty({
-          name: config.id,
-          type: `prismicT.ImageField<${thumbnailNames}>`,
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      } else {
-        config.interface.addProperty({
-          name: config.id,
-          type: "prismicT.ImageField<never>",
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      }
-      break;
-    }
-    case "IntegrationFields": {
-      const catalogType = config.model.config?.catalog ? config.fieldConfigs.integrationFields?.catalogTypes?.[config.model.config.catalog] : void 0;
-      config.interface.addProperty({
-        name: config.id,
-        type: catalogType ? `prismicT.IntegrationFields<${catalogType}>` : "prismicT.IntegrationFields",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Link": {
-      switch (config.model.config?.select) {
-        case types.CustomTypeModelLinkSelectType.Document: {
-          config.model.config;
-          config.interface.addProperty({
-            name: config.id,
-            type: "customtypes" in config.model.config && config.model.config.customtypes && config.model.config.customtypes.length > 0 ? `prismicT.RelationField<${config.model.config.customtypes.map((type) => `"${type}"`).join(" | ")}>` : "prismicT.RelationField",
-            docs: buildFieldDocs({
-              id: config.id,
-              model: config.model,
-              path: config.path,
-              tabName: config.tabName
-            })
-          });
-          break;
-        }
-        case types.CustomTypeModelLinkSelectType.Media: {
-          config.interface.addProperty({
-            name: config.id,
-            type: "prismicT.LinkToMediaField",
-            docs: buildFieldDocs({
-              id: config.id,
-              model: config.model,
-              path: config.path,
-              tabName: config.tabName
-            })
-          });
-          break;
-        }
-        default: {
-          config.interface.addProperty({
-            name: config.id,
-            type: "prismicT.LinkField",
-            docs: buildFieldDocs({
-              id: config.id,
-              model: config.model,
-              path: config.path,
-              tabName: config.tabName
-            })
-          });
-        }
-      }
-      break;
-    }
-    case "Number": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.NumberField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "StructuredText": {
-      const isTitleField = config.model.config && "single" in config.model.config && config.model.config.single && config.model.config.single.split(",").every((blockType) => /heading/.test(blockType));
-      if (isTitleField) {
-        config.interface.addProperty({
-          name: config.id,
-          type: "prismicT.TitleField",
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      } else {
-        config.interface.addProperty({
-          name: config.id,
-          type: "prismicT.RichTextField",
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      }
-      break;
-    }
-    case "Select": {
-      const options = config.model.config?.options?.map((option) => `"${option}"`).join(" | ");
-      const hasDefault = Boolean(config.model.config?.default_value);
-      if (hasDefault) {
-        config.interface.addProperty({
-          name: config.id,
-          type: `prismicT.SelectField<${options || "string"}, "filled">`,
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      } else {
-        config.interface.addProperty({
-          name: config.id,
-          type: `prismicT.SelectField<${options}>`,
-          docs: buildFieldDocs({
-            id: config.id,
-            model: config.model,
-            path: config.path,
-            tabName: config.tabName
-          })
-        });
-      }
-      break;
-    }
-    case "Text": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.KeyTextField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Timestamp": {
-      config.interface.addProperty({
-        name: config.id,
-        type: "prismicT.TimestampField",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Group": {
-      const itemInterface = config.sourceFile.addInterface({
-        name: buildTypeName(
-          config.path[0].id,
-          "Document",
-          "Data",
-          config.id,
-          "Item"
-        ),
-        docs: [
-          {
-            description: (writer) => {
-              const humanReadablePath = getHumanReadableFieldPath({
-                path: [
-                  ...config.path,
-                  {
-                    id: config.id,
-                    model: config.model
-                  }
-                ]
-              });
-              writer.writeLine(`Item in ${humanReadablePath}`);
-            }
-          }
-        ],
-        isExported: true
-      });
-      if (config.model.config?.fields) {
-        addInterfacePropertiesForFields({
-          interface: itemInterface,
-          sourceFile: config.sourceFile,
-          fields: config.model.config.fields,
-          path: [
-            ...config.path,
-            {
-              id: config.id,
-              model: config.model
-            }
-          ],
-          fieldConfigs: config.fieldConfigs
-        });
-      }
-      config.interface.addProperty({
-        name: config.id,
-        type: `prismicT.GroupField<Simplify<${itemInterface.getName()}>>`,
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    case "Slices": {
-      const choiceInterfaceNames = [];
-      if (config.model.config?.choices) {
-        for (const choiceId in config.model.config.choices) {
-          const choice = config.model.config.choices[choiceId];
-          if (choice.type === types.CustomTypeModelSliceType.SharedSlice) {
-            choiceInterfaceNames.push(
-              buildSharedSliceInterfaceNamePart({ id: choiceId })
-            );
-          } else if (choice.type === types.CustomTypeModelSliceType.Slice) {
-            let primaryInterface;
-            if (choice["non-repeat"] && Object.keys(choice["non-repeat"]).length > 0) {
-              primaryInterface = config.sourceFile.addInterface({
-                name: buildTypeName(
-                  config.path[0].id,
-                  "Document",
-                  "Data",
-                  config.id,
-                  choiceId,
-                  "Slice",
-                  "Primary"
-                ),
-                docs: [
-                  {
-                    description: (writer) => {
-                      const humanReadablePath = getHumanReadableFieldPath({
-                        path: [
-                          ...config.path,
-                          {
-                            id: config.id,
-                            model: config.model
-                          },
-                          {
-                            id: choiceId,
-                            model: choice
-                          },
-                          {
-                            id: "primary",
-                            label: "Primary"
-                          }
-                        ]
-                      });
-                      writer.writeLine(
-                        `Primary content in ${humanReadablePath}`
-                      );
-                    }
-                  }
-                ]
-              });
-              addInterfacePropertiesForFields({
-                interface: primaryInterface,
-                sourceFile: config.sourceFile,
-                fields: choice["non-repeat"],
-                path: [
-                  ...config.path,
-                  {
-                    id: config.id,
-                    model: config.model
-                  },
-                  {
-                    id: choiceId,
-                    model: choice
-                  },
-                  {
-                    id: "primary",
-                    label: "Primary"
-                  }
-                ],
-                fieldConfigs: config.fieldConfigs
-              });
-            }
-            let itemInterface;
-            if (choice.repeat && Object.keys(choice.repeat).length > 0) {
-              itemInterface = config.sourceFile.addInterface({
-                name: buildTypeName(
-                  config.path[0].id,
-                  "Document",
-                  "Data",
-                  config.id,
-                  choiceId,
-                  "Slice",
-                  "Item"
-                ),
-                docs: [
-                  {
-                    description: (writer) => {
-                      const humanReadablePath = getHumanReadableFieldPath({
-                        path: [
-                          ...config.path,
-                          {
-                            id: config.id,
-                            model: config.model
-                          },
-                          {
-                            id: choiceId,
-                            model: choice
-                          },
-                          {
-                            id: "items",
-                            label: "Items"
-                          }
-                        ]
-                      });
-                      writer.writeLine(`Item in ${humanReadablePath}`);
-                    }
-                  }
-                ],
-                isExported: true
-              });
-              addInterfacePropertiesForFields({
-                interface: itemInterface,
-                sourceFile: config.sourceFile,
-                fields: choice.repeat,
-                path: [
-                  ...config.path,
-                  {
-                    id: config.id,
-                    model: config.model
-                  },
-                  {
-                    id: choiceId,
-                    model: choice
-                  },
-                  {
-                    id: "items",
-                    label: "Items"
-                  }
-                ],
-                fieldConfigs: config.fieldConfigs
-              });
-            }
-            const sliceType = config.sourceFile.addTypeAlias({
-              name: buildTypeName(
-                config.path[0].id,
-                "Document",
-                "Data",
-                config.id,
-                choiceId,
-                "Slice"
-              ),
-              type: `prismicT.Slice<"${choiceId}", ${primaryInterface ? `Simplify<${primaryInterface.getName()}>` : "Record<string, never>"}, ${itemInterface ? `Simplify<${itemInterface.getName()}>` : "never"}>`,
-              isExported: true
-            });
-            choiceInterfaceNames.push(sliceType.getName());
-          }
-        }
-      }
-      const slicesType = config.sourceFile.addTypeAlias({
-        name: buildTypeName(
-          config.path[0].id,
-          "Document",
-          "Data",
-          config.id,
-          "Slice"
-        ),
-        type: choiceInterfaceNames.length > 0 ? choiceInterfaceNames.join(" | ") : "never",
-        docs: [
-          {
-            description: (writer) => {
-              const humanReadablePath = getHumanReadableFieldPath({
-                path: [
-                  ...config.path,
-                  {
-                    id: config.id,
-                    model: config.model
-                  }
-                ]
-              });
-              writer.writeLine(`Slice for *${humanReadablePath}*`);
-            }
-          }
-        ]
-      });
-      config.interface.addProperty({
-        name: config.id,
-        type: `prismicT.SliceZone<${slicesType.getName()}>`,
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-      break;
-    }
-    default: {
-      config.interface.addProperty({
-        name: config.id,
-        type: "unknown",
-        docs: buildFieldDocs({
-          id: config.id,
-          model: config.model,
-          path: config.path,
-          tabName: config.tabName
-        })
-      });
-    }
-  }
-};
-const addInterfacePropertiesForFields = (config) => {
-  for (const name in config.fields) {
-    addInterfacePropertyForField({
-      ...config,
-      id: name.includes("-") || name.includes(":") || /^[0-9]/.test(name) ? `"${name}"` : name,
-      model: config.fields[name],
-      tabName: config.tabName
-    });
-  }
-};
-
-const collectCustomTypeFields = (model) => {
-  return Object.assign({}, ...Object.values(model.json));
-};
-const addTypeAliasForCustomType = ({
-  model,
-  sourceFile,
-  localeIDs,
-  fieldConfigs
-}) => {
-  const { uid: uidField, ...fields } = collectCustomTypeFields(model);
-  const hasDataFields = Object.keys(fields).length > 0;
-  const hasUIDField = Boolean(uidField);
-  let dataInterface;
-  if (hasDataFields) {
-    dataInterface = sourceFile.addInterface({
-      name: buildTypeName(model.id, "Document", "Data"),
-      docs: [
-        {
-          description: `Content for ${model.label} documents`
-        }
-      ]
-    });
-    for (const tabName in model.json) {
-      const { uid: _uidField, ...tabFields } = model.json[tabName];
-      addInterfacePropertiesForFields({
-        fields: tabFields,
-        interface: dataInterface,
-        sourceFile,
-        path: [
-          {
-            id: model.id,
-            model
-          }
-        ],
-        fieldConfigs,
-        tabName
-      });
-    }
-  } else {
-    dataInterface = sourceFile.addTypeAlias({
-      name: buildTypeName(model.id, "Document", "Data"),
-      type: `Record<string, never>`,
-      docs: [
-        {
-          description: `Content for ${model.label} documents`
-        }
-      ]
-    });
-  }
-  return sourceFile.addTypeAlias({
-    name: buildTypeName(model.id, "Document"),
-    typeParameters: [
-      {
-        name: "Lang",
-        constraint: "string",
-        default: localeIDs.length > 0 ? localeIDs.map((localeID) => `"${localeID}"`).join(" | ") : "string"
-      }
-    ],
-    type: hasUIDField ? `prismicT.PrismicDocumentWithUID<Simplify<${dataInterface.getName()}>, "${model.id}", Lang>` : `prismicT.PrismicDocumentWithoutUID<Simplify<${dataInterface.getName()}>, "${model.id}", Lang>`,
-    docs: [
-      {
-        description: (writer) => {
-          writer.writeLine(`${model.label} document from Prismic`);
-          writer.blankLine();
-          writer.writeLine(`- **API ID**: \`${model.id}\``);
-          writer.writeLine(`- **Repeatable**: \`${model.repeatable}\``);
-          writer.writeLine(
-            `- **Documentation**: ${CUSTOM_TYPES_DOCUMENTATION_URL}`
-          );
-        },
-        tags: [
-          {
-            tagName: "typeParam",
-            text: "Lang - Language API ID of the document."
-          }
-        ]
-      }
-    ],
-    isExported: true
-  });
-};
-
-const addTypeAliasForSharedSlice = (config) => {
-  const variationTypeNames = [];
-  for (const variation of config.model.variations) {
-    let primaryInterface;
-    if (variation.primary && Object.keys(variation.primary).length > 0) {
-      primaryInterface = config.sourceFile.addInterface({
-        name: buildTypeName(
-          buildSharedSliceInterfaceNamePart({ id: config.model.id }),
-          variation.id,
-          "Primary"
-        ),
-        docs: [
-          {
-            description: (writer) => {
-              const humanReadablePath = getHumanReadableFieldPath({
-                path: [
-                  {
-                    id: config.model.id,
-                    model: config.model
-                  },
-                  {
-                    id: "primary",
-                    label: "Primary"
-                  }
-                ]
-              });
-              writer.writeLine(`Primary content in ${humanReadablePath}`);
-            }
-          }
-        ]
-      });
-      addInterfacePropertiesForFields({
-        interface: primaryInterface,
-        sourceFile: config.sourceFile,
-        fields: variation.primary,
-        path: [
-          {
-            id: config.model.id,
-            model: config.model
-          },
-          {
-            id: "primary",
-            label: "Primary"
-          }
-        ],
-        fieldConfigs: config.fieldConfigs
-      });
-    }
-    let itemInterface;
-    if (variation.items && Object.keys(variation.items).length > 0) {
-      itemInterface = config.sourceFile.addInterface({
-        name: buildTypeName(
-          buildSharedSliceInterfaceNamePart({ id: config.model.id }),
-          variation.id,
-          "Item"
-        ),
-        docs: [
-          {
-            description: (writer) => {
-              const humanReadablePath = getHumanReadableFieldPath({
-                path: [
-                  {
-                    id: config.model.id,
-                    model: config.model
-                  },
-                  {
-                    id: "items",
-                    label: "Items"
-                  }
-                ]
-              });
-              writer.writeLine(`Item in ${humanReadablePath}`);
-            }
-          }
-        ],
-        isExported: true
-      });
-      addInterfacePropertiesForFields({
-        interface: itemInterface,
-        sourceFile: config.sourceFile,
-        fields: variation.items,
-        path: [
-          {
-            id: config.model.id,
-            model: config.model
-          },
-          {
-            id: "items",
-            label: "Items"
-          }
-        ],
-        fieldConfigs: config.fieldConfigs
-      });
-    }
-    const variationType = config.sourceFile.addTypeAlias({
-      name: buildTypeName(
-        buildSharedSliceInterfaceNamePart({ id: config.model.id }),
-        variation.id
-      ),
-      type: `prismicT.SharedSliceVariation<"${variation.id}", ${primaryInterface ? `Simplify<${primaryInterface.getName()}>` : "Record<string, never>"}, ${itemInterface ? `Simplify<${itemInterface.getName()}>` : "never"}>`,
-      docs: [
-        {
-          description: (writer) => {
-            writer.writeLine(
-              `${variation.name} variation for ${config.model.name} Slice`
-            );
-            writer.blankLine();
-            writer.writeLine(`- **API ID**: \`${variation.id}\``);
-            writer.writeLine(`- **Description**: \`${variation.description}\``);
-            writer.writeLine(
-              `- **Documentation**: ${SHARED_SLICES_DOCUMENTATION_URL}`
-            );
-          }
-        }
-      ],
-      isExported: true
-    });
-    variationTypeNames.push(variationType.getName());
-  }
-  const variationsType = config.sourceFile.addTypeAlias({
-    name: buildTypeName(config.model.id, "Slice", "Variation"),
-    type: variationTypeNames.length > 0 ? variationTypeNames.join(" | ") : "never",
-    docs: [
-      {
-        description: (writer) => {
-          const humanReadablePath = getHumanReadableFieldPath({
-            path: [
-              {
-                id: config.model.id,
-                model: config.model
-              }
-            ]
-          });
-          writer.writeLine(`Slice variation for *${humanReadablePath}*`);
-        }
-      }
-    ]
-  });
-  return config.sourceFile.addTypeAlias({
-    name: buildTypeName(
-      buildSharedSliceInterfaceNamePart({ id: config.model.id })
-    ),
-    type: `prismicT.SharedSlice<"${config.model.id}", ${variationsType.getName()}>`,
-    docs: [
-      {
-        description: (writer) => {
-          writer.writeLine(`${config.model.name} Shared Slice`);
-          writer.blankLine();
-          writer.writeLine(`- **API ID**: \`${config.model.id}\``);
-          writer.writeLine(
-            `- **Description**: \`${config.model.description}\``
-          );
-          writer.writeLine(
-            `- **Documentation**: ${SHARED_SLICES_DOCUMENTATION_URL}`
-          );
-        }
-      }
-    ],
-    isExported: true
-  });
-};
-
-const getSourceFileText = (sourceFile) => {
-  const text = sourceFile.print().replace(new RegExp(BLANK_LINE_IDENTIFIER, "g"), "");
-  return text;
-};
-
-const generateTypes = (config = {}) => {
-  const project = new tsMorph.Project({
-    useInMemoryFileSystem: true
-  });
-  const sourceFile = project.createSourceFile("types.d.ts");
-  sourceFile.addImportDeclaration({
-    moduleSpecifier: "@prismicio/types",
-    namespaceImport: "prismicT",
-    isTypeOnly: true
-  });
-  sourceFile.addStatements(BLANK_LINE_IDENTIFIER);
-  const simplifyTypeAlias = sourceFile.addTypeAlias({
-    name: "Simplify",
-    typeParameters: [
-      {
-        name: "T"
-      }
-    ],
-    type: `{ [KeyType in keyof T]: T[KeyType] }`
-  });
-  if (config.customTypeModels) {
-    for (const model of config.customTypeModels) {
-      addTypeAliasForCustomType({
-        model,
-        sourceFile,
-        localeIDs: config.localeIDs || [],
-        fieldConfigs: config.fieldConfigs || {}
-      });
-    }
-    if (config.customTypeModels.length > 0) {
-      sourceFile.addTypeAlias({
-        name: "AllDocumentTypes",
-        type: config.customTypeModels.map(
-          (customTypeModel) => buildTypeName(customTypeModel.id, "Document")
-        ).join(" | "),
-        isExported: true
-      });
-    }
-  }
-  if (config.sharedSliceModels) {
-    for (const model of config.sharedSliceModels) {
-      addTypeAliasForSharedSlice({
-        model,
-        sourceFile,
-        fieldConfigs: config.fieldConfigs || {}
-      });
-    }
-  }
-  if (config.clientIntegration?.includeCreateClientInterface || config.clientIntegration?.includeContentNamespace) {
-    sourceFile.addImportDeclaration({
-      moduleSpecifier: "@prismicio/client",
-      namespaceImport: "prismic",
-      isTypeOnly: true
-    });
-    const clientModuleDeclaration = sourceFile.addModule({
-      name: '"@prismicio/client"',
-      hasDeclareKeyword: true,
-      declarationKind: tsMorph.ModuleDeclarationKind.Module
-    });
-    if (config.clientIntegration.includeCreateClientInterface) {
-      clientModuleDeclaration.addInterface({
-        name: "CreateClient",
-        callSignatures: [
-          {
-            parameters: [
-              {
-                name: "repositoryNameOrEndpoint",
-                type: "string"
-              },
-              {
-                name: "options",
-                type: "prismic.ClientConfig",
-                hasQuestionToken: true
-              }
-            ],
-            returnType: (config.customTypeModels?.length || 0) > 0 ? "prismic.Client<AllDocumentTypes>" : "prismic.Client"
-          }
-        ]
-      });
-    }
-    if (config.clientIntegration.includeContentNamespace) {
-      const contentNamespaceDeclaration = clientModuleDeclaration.addModule({
-        name: "Content",
-        declarationKind: tsMorph.ModuleDeclarationKind.Namespace
-      });
-      const exportSymbols = sourceFile.getExportSymbols().filter((exportSymbol) => {
-        return exportSymbol.getName() !== simplifyTypeAlias.getName();
-      });
-      contentNamespaceDeclaration.addExportDeclaration({
-        isTypeOnly: true,
-        namedExports: exportSymbols.map((exportSymbol) => {
-          return {
-            name: exportSymbol.getName()
-          };
-        })
-      });
-    }
-  }
-  return getSourceFileText(sourceFile);
-};
-
-exports.generateTypes = generateTypes;
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const generateTypes = require("./generateTypes.cjs");
+const detectTypesProvider = require("./detectTypesProvider.cjs");
+exports.generateTypes = generateTypes.generateTypes;
+exports.detectTypesProvider = detectTypesProvider.detectTypesProvider;
 //# sourceMappingURL=index.cjs.map